<!DOCTYPE html>
<html lang="zh-Hans">

<!-- Head tag -->
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <!--Description-->
    
        <meta name="description" content="Note">
    

    <!--Author-->
    
        <meta name="author" content="兰陵忧患生">
    

    <!-- Title -->
    
    <title>MySQL 必知必会 | Lan</title>

    <!-- Bootstrap Core CSS -->
    <link href="//cdn.bootcss.com/bootstrap/3.3.6/css/bootstrap.min.css" rel="stylesheet">
    <link rel="stylesheet"
      href="//cdn.jsdelivr.net/gh/highlightjs/cdn-release@9.12.0/build/styles/default.min.css">
    <script src="//cdn.jsdelivr.net/gh/highlightjs/cdn-release@9.12.0/build/highlight.min.js"></script>

    <!-- Custom CSS -->
    <link rel="stylesheet" href="/css/style.css">

    <!-- Custom Fonts -->
    <link href="//cdn.bootcss.com/font-awesome/4.5.0/css/font-awesome.min.css" rel="stylesheet" type="text/css">
    <link href='//fonts.googleapis.com/css?family=Lora:400,700,400italic,700italic' rel='stylesheet' type='text/css'>
    <link href='//fonts.googleapis.com/css?family=Open+Sans:300italic,400italic,600italic,700italic,800italic,400,300,600,700,800' rel='stylesheet' type='text/css'>

    <!-- HTML5 Shim and Respond.js IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
    <script src="https://oss.maxcdn.com/libs/html5shiv/3.7.0/html5shiv.js"></script>
    <script src="https://oss.maxcdn.com/libs/respond.js/1.4.2/respond.min.js"></script>
    <![endif]-->
</head>

<body>

    <!-- Content -->
    <section class="article-container">
<!-- Back Home -->
<a class="nav-back" href="/">
    <i class="fa fa-puzzle-piece"></i>
</a>

<!-- Page Header -->
<header class="intro-header">
    <div class="container">
        <div class="row">
            <div class="col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
                <div class="post-heading">
                    <h1>MySQL 必知必会</h1>
                </div>
            </div>
        </div>
    </div>
</header>

<!-- Post Content -->
<article>
    <div class="container">
        <div class="row">
            <!-- TOC -->
            <div class="toc-article col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
    <ol class="toc"><li class="toc-item toc-level-1"><a class="toc-link" href="#了解-SQL"><span class="toc-text">了解 SQL</span></a></li><li class="toc-item toc-level-1"><a class="toc-link" href="#使用-MySQL"><span class="toc-text">使用 MySQL</span></a></li><li class="toc-item toc-level-1"><a class="toc-link" href="#检索数据"><span class="toc-text">检索数据</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#DISTINCT"><span class="toc-text">DISTINCT</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#LIMIT"><span class="toc-text">LIMIT</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#完全限定的表名"><span class="toc-text">完全限定的表名</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#排序检索数据"><span class="toc-text">排序检索数据</span></a></li><li class="toc-item toc-level-1"><a class="toc-link" href="#过滤数据"><span class="toc-text">过滤数据</span></a></li><li class="toc-item toc-level-1"><a class="toc-link" href="#数据过滤"><span class="toc-text">数据过滤</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#AND-操作符"><span class="toc-text">AND 操作符</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#OR-操作符"><span class="toc-text">OR 操作符</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#IN-操作符"><span class="toc-text">IN 操作符</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#NOT-操作符"><span class="toc-text">NOT 操作符</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#用通配符进行过滤"><span class="toc-text">用通配符进行过滤</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#LIKE-操作符"><span class="toc-text">LIKE 操作符</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#百分号（-）通配符"><span class="toc-text">百分号（%）通配符</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#下划线（-）通配符"><span class="toc-text">下划线（_）通配符</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#使用通配符的技巧"><span class="toc-text">使用通配符的技巧</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#用正则表达式进行搜索"><span class="toc-text">用正则表达式进行搜索</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#基本字符匹配"><span class="toc-text">基本字符匹配</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#进行-OR-匹配"><span class="toc-text">进行 OR 匹配</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#匹配几个字符之一"><span class="toc-text">匹配几个字符之一</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#匹配范围"><span class="toc-text">匹配范围</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#匹配特殊字符"><span class="toc-text">匹配特殊字符</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#匹配字符类"><span class="toc-text">匹配字符类</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#匹配多个实例"><span class="toc-text">匹配多个实例</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#定位符"><span class="toc-text">定位符</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#创建计算字段"><span class="toc-text">创建计算字段</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#拼接字段"><span class="toc-text">拼接字段</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#执行算术计算"><span class="toc-text">执行算术计算</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#使用数据处理函数"><span class="toc-text">使用数据处理函数</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#使用函数"><span class="toc-text">使用函数</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#文本处理函数"><span class="toc-text">文本处理函数</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#日期和时间处理函数"><span class="toc-text">日期和时间处理函数</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#数值处理函数"><span class="toc-text">数值处理函数</span></a></li></ol></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#汇总数据"><span class="toc-text">汇总数据</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#聚集函数"><span class="toc-text">聚集函数</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#AVG-函数"><span class="toc-text">AVG() 函数</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#COUNT-函数"><span class="toc-text">COUNT() 函数</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#MAX-MIN-函数"><span class="toc-text">MAX() MIN() 函数</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#SUM-函数"><span class="toc-text">SUM() 函数</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#聚集不同值"><span class="toc-text">聚集不同值</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#组合聚合函数"><span class="toc-text">组合聚合函数</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#分组数据"><span class="toc-text">分组数据</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#GROUP-BY"><span class="toc-text">GROUP BY</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#过滤分组"><span class="toc-text">过滤分组</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#分组和排序"><span class="toc-text">分组和排序</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#SELECT-子句顺序"><span class="toc-text">SELECT 子句顺序</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#使用子查询"><span class="toc-text">使用子查询</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#利用子查询进行过滤"><span class="toc-text">利用子查询进行过滤</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#作为计算字段使用子查询"><span class="toc-text">作为计算字段使用子查询</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#联结表"><span class="toc-text">联结表</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#关系表"><span class="toc-text">关系表</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#创建联结"><span class="toc-text">创建联结</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#内部联结"><span class="toc-text">内部联结</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#联结多个表"><span class="toc-text">联结多个表</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#创建高级联结"><span class="toc-text">创建高级联结</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#使用表别名"><span class="toc-text">使用表别名</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#使用不同类型的联结"><span class="toc-text">使用不同类型的联结</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#自联结"><span class="toc-text">自联结</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#自然联结"><span class="toc-text">自然联结</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#外部联结"><span class="toc-text">外部联结</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#使用带聚集函数的联结"><span class="toc-text">使用带聚集函数的联结</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#使用联结和联结条件"><span class="toc-text">使用联结和联结条件</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#组合查询"><span class="toc-text">组合查询</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#UNION-规则"><span class="toc-text">UNION 规则</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#包含或取消重复的行"><span class="toc-text">包含或取消重复的行</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#对组合查询结果排序"><span class="toc-text">对组合查询结果排序</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#全文本搜索"><span class="toc-text">全文本搜索</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#使用全文本搜索"><span class="toc-text">使用全文本搜索</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#启用全文本搜索支持"><span class="toc-text">启用全文本搜索支持</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#进行全文本搜索"><span class="toc-text">进行全文本搜索</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#使用查询扩展"><span class="toc-text">使用查询扩展</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#布尔文本搜索"><span class="toc-text">布尔文本搜索</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#全文本搜索的使用说明"><span class="toc-text">全文本搜索的使用说明</span></a></li></ol></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#插入数据"><span class="toc-text">插入数据</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#数据插入"><span class="toc-text">数据插入</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#插入完整的行"><span class="toc-text">插入完整的行</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#插入多个行"><span class="toc-text">插入多个行</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#插入检索出的数据"><span class="toc-text">插入检索出的数据</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#更新和删除数据"><span class="toc-text">更新和删除数据</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#更新数据"><span class="toc-text">更新数据</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#删除数据"><span class="toc-text">删除数据</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#更新和删除的指导原则"><span class="toc-text">更新和删除的指导原则</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#创建和操纵表"><span class="toc-text">创建和操纵表</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#创建表"><span class="toc-text">创建表</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#表创建基础"><span class="toc-text">表创建基础</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#使用-NULL-值"><span class="toc-text">使用 NULL 值</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#主键再介绍"><span class="toc-text">主键再介绍</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#使用-AUTO-INCREMENT"><span class="toc-text">使用 AUTO_INCREMENT</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#指定默认值"><span class="toc-text">指定默认值</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#引擎类型"><span class="toc-text">引擎类型</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#更新表"><span class="toc-text">更新表</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#删除表"><span class="toc-text">删除表</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#重命名表"><span class="toc-text">重命名表</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#使用视图"><span class="toc-text">使用视图</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#视图"><span class="toc-text">视图</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#为什么使用视图"><span class="toc-text">为什么使用视图</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#视图的规则和限制"><span class="toc-text">视图的规则和限制</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#视图-1"><span class="toc-text">视图</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#利用视图简化复杂的联结"><span class="toc-text">利用视图简化复杂的联结</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#用视图重新格式化检索出的数据"><span class="toc-text">用视图重新格式化检索出的数据</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#用视图过滤不想要的数据"><span class="toc-text">用视图过滤不想要的数据</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#使用视图与计算字段"><span class="toc-text">使用视图与计算字段</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#更新视图"><span class="toc-text">更新视图</span></a></li></ol></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#使用存储过程"><span class="toc-text">使用存储过程</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#存储过程"><span class="toc-text">存储过程</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#为什么要使用存储过程"><span class="toc-text">为什么要使用存储过程</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#使用存储过程-1"><span class="toc-text">使用存储过程</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#执行存储过程"><span class="toc-text">执行存储过程</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#创建存储过程"><span class="toc-text">创建存储过程</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#删除存储过程"><span class="toc-text">删除存储过程</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#使用参数"><span class="toc-text">使用参数</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#建立智能存储过程"><span class="toc-text">建立智能存储过程</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#检查存储过程"><span class="toc-text">检查存储过程</span></a></li></ol></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#使用游标"><span class="toc-text">使用游标</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#游标"><span class="toc-text">游标</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#使用游标-1"><span class="toc-text">使用游标</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#创建游标"><span class="toc-text">创建游标</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#打开和关闭游标"><span class="toc-text">打开和关闭游标</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#使用游标数据"><span class="toc-text">使用游标数据</span></a></li></ol></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#触发器"><span class="toc-text">触发器</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#触发器-1"><span class="toc-text">触发器</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#创建触发器"><span class="toc-text">创建触发器</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#删除触发器"><span class="toc-text">删除触发器</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#使用触发器"><span class="toc-text">使用触发器</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#INSERT-触发器"><span class="toc-text">INSERT 触发器</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#DELETE-触发器"><span class="toc-text">DELETE 触发器</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#UPDATE-触发器"><span class="toc-text">UPDATE 触发器</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#关于触发器的进一步介绍"><span class="toc-text">关于触发器的进一步介绍</span></a></li></ol></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#管理事务处理"><span class="toc-text">管理事务处理</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#事务处理"><span class="toc-text">事务处理</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#控制事务"><span class="toc-text">控制事务</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#使用-ROLLBACK"><span class="toc-text">使用 ROLLBACK</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#使用-COMMIT"><span class="toc-text">使用 COMMIT</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#使用保留点"><span class="toc-text">使用保留点</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#更改默认的提交行为"><span class="toc-text">更改默认的提交行为</span></a></li></ol></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#全球化和本地化"><span class="toc-text">全球化和本地化</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#字符集和校对顺序"><span class="toc-text">字符集和校对顺序</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#使用字符集和校对顺序"><span class="toc-text">使用字符集和校对顺序</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#安全管理"><span class="toc-text">安全管理</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#访问控制"><span class="toc-text">访问控制</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#管理用户"><span class="toc-text">管理用户</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#创建用户账号"><span class="toc-text">创建用户账号</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#删除用户账号"><span class="toc-text">删除用户账号</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#设置访问权限"><span class="toc-text">设置访问权限</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#更改口令"><span class="toc-text">更改口令</span></a></li></ol></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#数据库维护"><span class="toc-text">数据库维护</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#备份数据"><span class="toc-text">备份数据</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#进行数据库维护"><span class="toc-text">进行数据库维护</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#诊断启动问题"><span class="toc-text">诊断启动问题</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#查看日志文件"><span class="toc-text">查看日志文件</span></a></li></ol></li><li class="toc-item toc-level-1"><a class="toc-link" href="#改善性能"><span class="toc-text">改善性能</span></a></li><li class="toc-item toc-level-1"><a class="toc-link" href="#附录A-MySQL-入门"><span class="toc-text">附录A MySQL 入门</span></a></li><li class="toc-item toc-level-1"><a class="toc-link" href="#附录B-样例表"><span class="toc-text">附录B 样例表</span></a></li><li class="toc-item toc-level-1"><a class="toc-link" href="#附录C-MySQL-语句的语法"><span class="toc-text">附录C MySQL 语句的语法</span></a></li><li class="toc-item toc-level-1"><a class="toc-link" href="#附录D-MySQL-数据类型"><span class="toc-text">附录D MySQL 数据类型</span></a></li><li class="toc-item toc-level-1"><a class="toc-link" href="#附录E-MySQL-保留字"><span class="toc-text">附录E MySQL 保留字</span></a></li></ol>
</div>

            <!-- Post Main Content -->
            <div class="post-content col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
                <h1 id="了解-SQL"><a href="#了解-SQL" class="headerlink" title="了解 SQL"></a>了解 SQL</h1><ul>
<li>应该总是定义主键</li>
<li><p>表中的任何列都可以作为主键</p>
<ul>
<li>任意两行都不具备相同的主键值；</li>
<li>每个行都必须具有一个主键值（主键列不允许 NULL 值）</li>
</ul>
</li>
<li><p>主键好习惯</p>
<ul>
<li>不更新主键列中的值</li>
<li>不重用主键列的值</li>
<li>不在主键列中使用可能会更改的值</li>
</ul>
</li>
</ul>
<h1 id="使用-MySQL"><a href="#使用-MySQL" class="headerlink" title="使用 MySQL"></a>使用 MySQL</h1><pre><code class="SQL">USE crashcourse;
SHOW DATABASES;
SHOW TABLES;
SHOW COLUMNS 
FROM customers; // 显示表列
    DESCRIBE customers; // 上面这句的快捷方式
SHOW STATUS; // 用于显示广泛的服务器状态信息
SHOW CREATE DATABASE／ SHOW CREATE TABLE 分别用来创建特定数据库或表的 MySQL 语句
SHOW GRANTS; // 用来显示授予用户（所有用户或特定用户）的安全权限
SHOW ERRORS ／ SHOW WARNINGS // 用来显示服务器错误或警告消息

HELP SHOW // 显示允许的 SHOW 语句
</code></pre>
<h1 id="检索数据"><a href="#检索数据" class="headerlink" title="检索数据"></a>检索数据</h1><ul>
<li>虽然 SQL 是不区分大小写的，但有些标识符（如数据库名，表名，列名）可能不同。最佳方式是按照大小写的惯例，且使用时保持一致。</li>
<li>一般，除非你确实需要表中的每个列，否则最好别使用 * 通配符。（检索不需要的列通常会降低检索和应用程序的性能）</li>
</ul>
<h2 id="DISTINCT"><a href="#DISTINCT" class="headerlink" title="DISTINCT"></a>DISTINCT</h2><pre><code>```SQL
SELECT DISTINCT vend_id 
FROM products; //指示 MySQL 只返回不同的值。
// 不能部分使用 DISTINCT 。DISTINCT 关键字应用于所有的列而不仅是前置它的列。
SELECT DISTINCT vend_id, prod_price; // 除非指定的两个列都不同，否则所有行都将被检索出来。
```
</code></pre><h2 id="LIMIT"><a href="#LIMIT" class="headerlink" title="LIMIT"></a>LIMIT</h2><pre><code>```SQL
SELECT pro_name 
FROM products LIMIT 5; // 指示 MySQL 返回不多于 5 行。

SELECT pro_name 
FROM products LIMIT 5,5; // 指示 MySQL 返回从行 5 开始的 5 行。第一个数为开始位置，第二个数为要检索的行数。

// 检索出来的第一行为行 0 而不是行 1 。
LIMIT 1,1; // 将检索出第二行而不是第一行。
// 如果没有足够的行，MySQL 将只返回它能返回的那么多行。

// MySQL 5 的 LIMIT 语法
LIMIT 4 OFFSET 3 // 从行 3 开始取 4 行，就像 LIMIT 3,4 一样
```
</code></pre><h2 id="完全限定的表名"><a href="#完全限定的表名" class="headerlink" title="完全限定的表名"></a>完全限定的表名</h2><pre><code class="SQL">SELECT products.pro_name 
FROM crashcourse.products;
</code></pre>
<h1 id="排序检索数据"><a href="#排序检索数据" class="headerlink" title="排序检索数据"></a>排序检索数据</h1><pre><code class="SQL">SELECT prod_name 
FROM products;

// 通过非选择列进行排序。

SELECT prod_id, prod_price, prod_name 
FROM products 
ORDER BY prod_price, prod_name; // 首先按照价格，然后再按名称排序

SELECT prod_id, prod_price, prod_name 
FROM products 
ORDER BY prod_price DESC; // 降序

SELECT prod_id, prod_price, prod_name 
FROM products 
ORDER BY prod_price DESC, prod_name; // DESC 关键字只应用到直接位于其前面的列名。

// 如果在多个列降序排序。必须对每个列指定 DESC 关键字

ASC 升序（默认）

// 在字典（dirtionary）排序顺序中，A 被视为与 a 相同，这是 MySQL 的默认行为。

SELECT prod_price 
FROM products 
ORDER BY prod_price DESC 
LIMIT 1; // 找出列中最高的值
</code></pre>
<h1 id="过滤数据"><a href="#过滤数据" class="headerlink" title="过滤数据"></a>过滤数据</h1><pre><code class="SQL">SELECT prod_name, prod_price 
FROM products 
WHERE prod_price = 2.50;

// SQL过滤，应用过滤

// 操作符
=, &lt;&gt;, !=, &lt;, &lt;=, &gt;, &gt;=, BETWEEN

// MySQL 在执行匹配时默认不区分大小写

// 将值与串类型的列进行比较，则需要限定引号。

SELECT prod_name, prod_price 
FROM products 
WHERE prod_price BETWEEN 5 AND 10;

// 在创建表时，表设计人员可以指定其中的列是否可以不包括值。在一个列不包含值时，称其为包含空值 NULL
// NULL 无值，它与字段包含 0 ，空字符或仅仅包含空格不同。
SELECT prod_name 
FROM products 
WHERE prod_price IS NULL;
</code></pre>
<h1 id="数据过滤"><a href="#数据过滤" class="headerlink" title="数据过滤"></a>数据过滤</h1><h2 id="AND-操作符"><a href="#AND-操作符" class="headerlink" title="AND 操作符"></a>AND 操作符</h2><h2 id="OR-操作符"><a href="#OR-操作符" class="headerlink" title="OR 操作符"></a>OR 操作符</h2><pre><code>```SQL
SELECT prod_name, prod_price 
FROM products 
WHERE (vend_id = 1002 OR vend_id = 1003) AND prod_price &gt;= 10;
```
</code></pre><h2 id="IN-操作符"><a href="#IN-操作符" class="headerlink" title="IN 操作符"></a>IN 操作符</h2><pre><code class="SQL">SELECT prod_name, prod_price
FROM products
WHERE vend_id
IN (1002, 1003)
ORDER BY prod_name;

// IN 操作符后跟由逗号分隔的合法值清单，整个清单必须括在圆括号中。
</code></pre>
<ul>
<li><p>优点</p>
<ul>
<li>在使用长的合法选项清单时，IN 操作符的语法更清楚且更直观。</li>
<li>在使用 IN 时，计算的次序更容易管理。</li>
<li>IN 操作符一般比 OR 操作符清单执行更快。</li>
<li>IN 的最大优点是可以包含其他 SELECT 语句，使得能够更动态地建立 WHERE 子句。</li>
</ul>
</li>
</ul>
<h2 id="NOT-操作符"><a href="#NOT-操作符" class="headerlink" title="NOT 操作符"></a>NOT 操作符</h2><pre><code class="SQL">// NOT 用来否定后跟条件的关键字
SELECT prod_name, prod_price
FROM products
WHERE vend_id NOT IN (1002, 1003)
ORDER BY prod_name;
</code></pre>
<ul>
<li>MySQL 支持使用 NOT 对 IN，BETWEEN 和 EXISTS 子句取反，这与多数其他 DBMS 允许使用 NOT 对各种条件取反很大的差别。</li>
</ul>
<h1 id="用通配符进行过滤"><a href="#用通配符进行过滤" class="headerlink" title="用通配符进行过滤"></a>用通配符进行过滤</h1><h2 id="LIKE-操作符"><a href="#LIKE-操作符" class="headerlink" title="LIKE 操作符"></a>LIKE 操作符</h2><ul>
<li>通配符（wildcard） 用来匹配值的一部分的特殊字符。</li>
<li>搜索模式（search pattern） 由字面值，通配符或两者组合构成的搜索条件。</li>
<li>操作符何时不是操作符？答案是在它作为谓词时。从技术上说，LIKE是谓语而不是操作符。</li>
</ul>
<h3 id="百分号（-）通配符"><a href="#百分号（-）通配符" class="headerlink" title="百分号（%）通配符"></a>百分号（%）通配符</h3><pre><code class="SQL">// % 表示任何字符出现任意次数
SELECT prod_id, prod_name
FROM products
WHERE prod_name
LIKE &#39;jet%&#39;; // 不区分大小写

// 根据 MySQL 的配置方式，搜索可以是区分大小写的。
// 通配符可在搜索模式中任意位置使用，并且可以使用多个通配符。
SELECT prod_id, prod_name
FROM products
WHERE prod_name LIKE &#39;%anvil%&#39;;

SELECT prod_name
FROM products
WHERE prod_name LIKE &#39;s%e&#39;;

//% 代表搜索模式中给定位置的 0 个，1 个或多个字符。

WHERE prod_name LIKE &#39;%&#39;; // 不能匹配用值 NULL 作为产品名的行
</code></pre>
<h3 id="下划线（-）通配符"><a href="#下划线（-）通配符" class="headerlink" title="下划线（_）通配符"></a>下划线（_）通配符</h3><pre><code class="SQL">// _ 总是匹配一个字符
SELECT prod_id, prod_name
FROM products
WHERE prod_name LIKE &#39;_ ton anvil&#39;;
</code></pre>
<h2 id="使用通配符的技巧"><a href="#使用通配符的技巧" class="headerlink" title="使用通配符的技巧"></a>使用通配符的技巧</h2><ul>
<li>通配符搜索的处理一般要比前面讨论的其他搜索所花时间更长。</li>
<li><p>技巧</p>
<ul>
<li>不要过度使用通配符。如果其他操作符能达到相同的目的，应该使用其他操作符。</li>
<li>在确实需要使用通配符时，除非绝对有必要，否则不要把它们用来在搜索模式的开始处。把通配符置于搜索模式的开始处，搜索起来是最慢的。</li>
<li>仔细注意通配符的位置。</li>
</ul>
</li>
</ul>
<h1 id="用正则表达式进行搜索"><a href="#用正则表达式进行搜索" class="headerlink" title="用正则表达式进行搜索"></a>用正则表达式进行搜索</h1><ul>
<li>MySQL 仅支持多数正则表达式实现的一个很小的子集。</li>
</ul>
<h2 id="基本字符匹配"><a href="#基本字符匹配" class="headerlink" title="基本字符匹配"></a>基本字符匹配</h2><pre><code class="SQL">SELECT prod_name
FROM products
WHERE prod_name REGEXP &#39;10000&#39;
ORDER BY prod_name; // 检索列 prod_name 包含文本 1000 的所有行。

SELECT prod_name
FROM products
WHERE prod_name REGEXP &#39;.000&#39;
ORDER BY prod_name; // . 表示匹配任意一个字符。

// MySQL中的正则表达式匹配（自版本 3.23.4 后），不区分大小写。
// 为区分大小写，可使用 BINARY 关键字。
WHERE prod_name REGEXP BINARY &#39;JetPack .000&#39;;
</code></pre>
<h2 id="进行-OR-匹配"><a href="#进行-OR-匹配" class="headerlink" title="进行 OR 匹配"></a>进行 OR 匹配</h2><pre><code class="SQL">// 为搜索两个串之一，使用 | 
SELECT prod_name
FROM products
WHERE prod_name REGEXP &#39;1000|2000&#39;
ORDER BY prod_name;
</code></pre>
<h2 id="匹配几个字符之一"><a href="#匹配几个字符之一" class="headerlink" title="匹配几个字符之一"></a>匹配几个字符之一</h2><pre><code class="SQL">// 匹配任何单一字符，指定一组用[和]括起来的字符完成
SELECT prod_name
FROM products
WHERE prod_name REGEXP &#39;[123] Ton&#39;
ORDER BY prod_name;

// [] 是另一种形式的 OR 语句。
[123]Ton 是 [1|2|3]Ton 缩写。
// 但是需要 [] 来定义 OR 语句查找什么。
// 反例：
SELECT prod_name
FROM products
WHERE prod_name REGEXP &#39;1|2|3 Ton&#39;
ORDER BY prod_name; // &#39;1&#39; 或 &#39;2&#39; 或 &#39;3 ton&#39;

// 字符集合也可以被否定。在集合的开始处放置一个 ^ 即可。
[^123]
</code></pre>
<h2 id="匹配范围"><a href="#匹配范围" class="headerlink" title="匹配范围"></a>匹配范围</h2><pre><code class="SQL">// 集合可用来定义要匹配的一个或多个字符。
// 匹配数字 0 到 9
[0123456789] 等价于 [0-9]
[a-z] // 匹配任意字母字符
SELECT prod_name
FROM products
WHERE prod_name REGEXP &#39;[1-5] Ton&#39;
ORDER BY prod_name;
</code></pre>
<h2 id="匹配特殊字符"><a href="#匹配特殊字符" class="headerlink" title="匹配特殊字符"></a>匹配特殊字符</h2><pre><code class="SQL">// 为了匹配特殊字符，必须用 \\ 为前导。
SELECT vend_name
FROM vendors
WHERE vend_name REGEXP &#39;\\.&#39;
ORDER BY vend_name; // 转译（escaping）

// &#39;\\&#39; 也用来引用元字符（具有特殊含义的字符）
&#39;\\f&#39; // 换页
&#39;\\n&#39; // 换行
&#39;\\r&#39; // 回车
&#39;\\t&#39; // 制表
&#39;\\v&#39; // 纵向制表

&#39;\\\&#39; // 匹配反斜杠（\）字符本身
</code></pre>
<ul>
<li>多数正则表达式实现使用单个反斜杠转义特殊字符，以便能使用这些字符本身。但 MySQL 要求两个反斜杠（ MySQL 自己解释一个，正则表达式库解释另一个）</li>
</ul>
<h2 id="匹配字符类"><a href="#匹配字符类" class="headerlink" title="匹配字符类"></a>匹配字符类</h2><ul>
<li>使用预定义的字符集，称为字符类（ character class ）</li>
</ul>
<pre><code class="SQL">[:alnum:] // 任意字母和数字（同 [a-zA-Z0-9] ）
[:alpha:] // 任意字符（同 [a-zA-Z] ）
[:blank:] // 空格和制表 （同 [\\t] ）
[:cntrl:] // ASCII 控制字符（ ASCII 0 到 31 和 127）
[:digit:] // 任意数字（同 [0-9] ）
[:graph:] // 与 [:print:] 相同，但不包括空格
[:lower:] // 任意小写字母（同 [a-z] ）
[:print:] // 任意可打印字符
[:punct:] // 即不在 [:alnum:] 又不在 [:cntrl:] 中的任意字符
[:space:] // 包括空格在内的任意空白字符（同 [\\f\\n\\r\\t\\v] ）
[:upper:] // 任意大写字母（同 [A-Z] ）
[:xdigit:] // 任意十六进制数字（同 [a-fA-F0-9] ）
</code></pre>
<h2 id="匹配多个实例"><a href="#匹配多个实例" class="headerlink" title="匹配多个实例"></a>匹配多个实例</h2><pre><code class="SQL">* // 0 个或多个匹配
+ // 1 个或多个匹配 （等于 {1,} ）
? // 0 个或 1个匹配 （等于 {0,1} ）
{n} // 指定数目的匹配
{n,} // 不少于指定数目的匹配
{n,m} // 匹配数目的范围（ m 不超过 255 ）

SELECT prod_name
FROM products
WHERE prod_name REGEXP &#39;\\([0-9] stick?\\)&#39;
ORDER BY prod_name; // ? 匹配它前面的任何字符的 0 次或 1 次出现

SELECT prod_name
FROM products
WHERE prod_name REGEXP &#39;[[:digit:]]{4}&#39;
</code></pre>
<h2 id="定位符"><a href="#定位符" class="headerlink" title="定位符"></a>定位符</h2><pre><code class="SQL">// 为了匹配特定位置的文本
^ // 文本的开始
$ // 文本的结尾
[[:&lt;:]] // 词的开始
[[:&gt;:]] // 词的结尾

SELECT prod_name
FROM products
WHERE prod_name REGEXP &#39;^[0-9\\.]&#39;
</code></pre>
<ul>
<li>^ 有两种用法。在集合中（ 用 [ 和 ] 定义 ），用它来否定该集合，否则，用来指串的开始处。</li>
<li>LIKE 匹配整个串而 REGEXP 匹配子串。利用定位符，通过用 ^ 开始每个表达式，用 $ 结束每个表达式，可以使 REGEXP 的作用与 LIKE 一样。</li>
</ul>
<pre><code class="SQL">// 可以在不使用数据库表的情况下用 SELECT 来测试正则表达式
// REGEXP 检查总是返回 0 (没有匹配) 或 1 （匹配）
SELECT &#39;hello&#39; REGEXP &#39;[0-9]&#39;;
</code></pre>
<h1 id="创建计算字段"><a href="#创建计算字段" class="headerlink" title="创建计算字段"></a>创建计算字段</h1><ul>
<li>字段（ field ） 基本上与列（ column ）的意思相同。不过数据库列一般称为列，而术语字段通常用在计算字段连接上。</li>
</ul>
<h2 id="拼接字段"><a href="#拼接字段" class="headerlink" title="拼接字段"></a>拼接字段</h2><ul>
<li>拼接（concatenate） 将值联结到一起构成单个值。</li>
</ul>
<pre><code class="SQL">// 多数 DBMS 使用 + 或 || 来实现拼接，MySQL 则使用 Concat() 函数来实现。

SELECT Concat(vend_name, &#39; （&#39;, vend_country, &#39;）&#39;)
FROM vendors
ORDER BY vend_name;

SELECT Concat(RTrim(vend_name), &#39; （&#39;, RTrim(vend_country), &#39;）&#39;); // RTrim() 函数去掉值右边的所有空格
// LTrim() 去掉串左边的空格 Trim() 去掉串左右两边的空格

// 别名（ alias ）
SELECT Concat(vend_name, &#39; （&#39;, vend_country, &#39;）&#39;) AS vend_title
FROM vendors
ORDER BY vend_name;

// 别名有时也称为 导出列 （derived column）
</code></pre>
<h2 id="执行算术计算"><a href="#执行算术计算" class="headerlink" title="执行算术计算"></a>执行算术计算</h2><pre><code class="SQL">SELECT prod_id, 
       quantity, 
       item_price, 
       quantity * item_price AS expanded_price
FROM orderitems
WHERE order_num = 20005;

// 测试 省略 FROM 子句
SELECT 3 * 2
SELECT Trim(&#39;abc&#39;)
SELECT Now() // Now 函数返回当前日期和时间
</code></pre>
<h1 id="使用数据处理函数"><a href="#使用数据处理函数" class="headerlink" title="使用数据处理函数"></a>使用数据处理函数</h1><ul>
<li>函数没有 SQL 的可移植性强（几乎每种主要的 DBMS 的实现都支持其他实现不支持的函数）</li>
</ul>
<h2 id="使用函数"><a href="#使用函数" class="headerlink" title="使用函数"></a>使用函数</h2><ul>
<li>用于处理文本串的文本函数</li>
<li>用于在数值上进行算术操作的数值函数</li>
<li>用于处理日期和时间值并从这些值中提取特定成分的日期和时间函数</li>
<li>返回 DBMS 正使用的特殊信息的系统函数</li>
</ul>
<h3 id="文本处理函数"><a href="#文本处理函数" class="headerlink" title="文本处理函数"></a>文本处理函数</h3><pre><code class="SQL">SELECT vend_name, Upper(vend_name) AS vend_name_upcase
FROM vendors
ORDER BY vend_name; // Upper() 将文本转换为大写

Left() // 返回串左边的字符
Length() // 返回串的长度
Locate() // 找出串的一个子串
Lower() // 将串转换为小写
LTrim() // 去掉串左边的空格
Right() // 返回串右边的字符
RTrim() // 去掉串右边的空格
Soundex() // 返回串的 SOUNDEX 值
SubString() // 返回子串的字符
Upper() // 将串转换为大写
</code></pre>
<ul>
<li>SOUNDEX 是一个将任何文本串转换为描述其语音表示的字母数字模式的算法。SOUNDEX 考虑了类似的发音字符和音节，使得能对串进行发音比较而不是字母比较。</li>
</ul>
<pre><code class="SQL">SELECT cust_name, cust_contact
FROM customers
WHERE Soundex(cust_contact) = Soundex(&#39;Y Lie&#39;);
// 匹配所有发音类似于 Y. Lie 的联系名
</code></pre>
<h3 id="日期和时间处理函数"><a href="#日期和时间处理函数" class="headerlink" title="日期和时间处理函数"></a>日期和时间处理函数</h3><pre><code class="SQL">addDate() // 增加一个日期（天，周等）
addTime() // 增加一个时间（时，分等）
CurDate() // 返回当前日期
CurTime() // 返回当前时间
Date() // 返回日期时间的日期部分
DateDiff() // 计算两个日期之差
Date_Add() // 高度灵活的日期运算函数
Date_Format() // 返回一个格式化的日期或时间串
Day() // 返回一个日期的天数部分
DayOfWeek() // 对于一个日期，返回对应的星期几
Hour() // 返回一个时间的小时部分
Minute() // 返回一个时间的分钟部分
Month() // 返回一个日期的月份部分
Now() // 返回当前日期和时间
Second() // 返回一个时间的秒部分
Time() // 返回一个日期时间的时间部分
Year() // 返回一个日期的年份部分
</code></pre>
<ul>
<li>MySQL 日期的格式，无论什么时候指定一个日期，日期必须为格式 yyyy-mm-dd ，这是首选的日期格式，它排除了多义性。</li>
<li>应该总是使用 4 位数字的年份</li>
</ul>
<pre><code class="SQL">SELECT cust_id, order_num
FROM orders
WHERE order_date = &#39;2005-09-01&#39;;

// 指示 MySQL 仅给出的日期与列中的日期部分进行比较，而不是将给出的日期与整个列值进行比较。
SELECT cust_id, order_num
FROM orders
WHERE Date(order_date) = &#39;2005-09-01&#39;;

// 如果要的是日期，请使用 Date() ，即使你知道相应的列只包含日期也是如此。
// Date() 和 Time() 都是在 MySQL 4.1.1 中第一次引入的。

// 匹配月份
SELECT cust_id, order_num
FROM orders
WHERE Date(order_date) BETWEEN &#39;2005-09-01&#39; AND &#39;2005-09-30&#39;;

// 或者
SELECT cust_id, order_num
FROM orders
WHERE Year(order_date) = 2005 AND Month(Order_date) = 9;
</code></pre>
<h3 id="数值处理函数"><a href="#数值处理函数" class="headerlink" title="数值处理函数"></a>数值处理函数</h3><pre><code class="SQL">Abs() // 返回一个数的绝对值
Cos() // 返回一个角度的余弦
Exp() // 返回一个数的指数值
Mod() // 返回除操作的余数
Pi() // 返回圆周率
Rand() // 返回一个随机数
Sin() // 返回一个角度的正弦
Sqrt() // 返回一个数的平方根
Tan() // 返回一个角度的正切
</code></pre>
<h1 id="汇总数据"><a href="#汇总数据" class="headerlink" title="汇总数据"></a>汇总数据</h1><h2 id="聚集函数"><a href="#聚集函数" class="headerlink" title="聚集函数"></a>聚集函数</h2><ul>
<li>确定表中行数</li>
<li>获得表中行组的和</li>
<li>找出表列（或所有行或某些特定的行）的最大值，最小值和平均值</li>
</ul>
<pre><code class="SQL">// 聚集函数 运行在行组上，计算和返回单个值的函数。

AVG() // 返回某列的平均值
COUNT() // 返回某列的行数
MAX() // 返回某列的最大值
MIN() // 返回某列的最小值
SUM() // 返回某列之和

// MySQL 还支持一系列的标准偏差聚集函数，但本书并未涉及这些内容。
</code></pre>
<h3 id="AVG-函数"><a href="#AVG-函数" class="headerlink" title="AVG() 函数"></a>AVG() 函数</h3><pre><code class="SQL">SELECT AVG(products) AS avg_price
FROM products;

// AVG() 只用于单个列
// 忽略列值为 NULL 的行
</code></pre>
<h3 id="COUNT-函数"><a href="#COUNT-函数" class="headerlink" title="COUNT() 函数"></a>COUNT() 函数</h3><ul>
<li><p>两种使用方式</p>
<ul>
<li>使用 COUNT(*) 对表中行的数目进行计数，不管表列中包含的是空值（ NULL ）还是非空值</li>
<li>使用 COUNT(column) 对特定列中具有值的行进行计数，忽略 NULL 值</li>
</ul>
</li>
</ul>
<pre><code class="SQL">SELECT COUNT(*) AS num_cust
FROM customers;

// 只对具有电子邮件地址的客户计数，忽略指定列为空的行
SELECT COUNT(cust_email) AS num_cust
FROM customers;
</code></pre>
<h3 id="MAX-MIN-函数"><a href="#MAX-MIN-函数" class="headerlink" title="MAX() MIN() 函数"></a>MAX() MIN() 函数</h3><pre><code class="SQL">// 返回指定列中的最大值。要求指定列名。
SELECT MAX(prod_price) AS max_price
FROM products;

SELECT MIN(prod_price) AS min_price
FROM products;

// MySQL 允许将它用来返回任意列中的最大值，包括返回文本列中的最大值。
// MAX()，MIN() 函数忽略列值为 NULL 的行
</code></pre>
<h3 id="SUM-函数"><a href="#SUM-函数" class="headerlink" title="SUM() 函数"></a>SUM() 函数</h3><pre><code class="SQL">// 返回指定列值的和
SELECT SUM(quantity) AS items_ordered
FROM orderitems
WHERE order_num = 20005;

SELECT SUM(item_price * quantity) AS total_price
FROM orderitems
WHERE order_num = 20005;

// 利用标准的算术操作符，所有聚集函数都可用来执行多个列的计算
// SUM() 函数忽略列值为 NULL 的行
</code></pre>
<h2 id="聚集不同值"><a href="#聚集不同值" class="headerlink" title="聚集不同值"></a>聚集不同值</h2><ul>
<li><p>MySQL 5及后期版本 聚集函数的 DISTINCT 的使用</p>
</li>
<li><p>以上 5 个聚集函数：</p>
<ul>
<li>对所有的行执行计算，指定 ALL 参数或不给参数（ ALL 是默认行为 ）</li>
<li>只包含不同的值，指定 DISTINCT 参数</li>
</ul>
</li>
</ul>
<pre><code class="SQL">SELECT AVG(DISTINCT prod_price) AS avg_price
FROM products
WHERE vend_id = 1003;
</code></pre>
<ul>
<li>DISTINCT 不能用于 COUNT(*)。DISTINCT 必须使用列名，不能用于计算或表达式</li>
</ul>
<h2 id="组合聚合函数"><a href="#组合聚合函数" class="headerlink" title="组合聚合函数"></a>组合聚合函数</h2><pre><code class="SQL">SELECT COUNT(*) AS num_items,
       MIN(prod_price) AS price_min,
       MAX(prod_price) AS price_max,
       AVG(prod_price) AS price_avg
FROM products;

// 在指定别名以包含某个聚集函数的结果时，不应该使用表中实际的列名。
</code></pre>
<h1 id="分组数据"><a href="#分组数据" class="headerlink" title="分组数据"></a>分组数据</h1><h2 id="GROUP-BY"><a href="#GROUP-BY" class="headerlink" title="GROUP BY"></a>GROUP BY</h2><pre><code class="SQL">SELECT vend_id, COUNT(*) AS num_prods
FROM products
GROUP BY vend_id;
</code></pre>
<ul>
<li><p>规定</p>
<ul>
<li>GROUP BY 子句可以包含任意数目的列。</li>
<li>如果在 GROUP BY 子句中嵌套了分组，数据将在最后规定的分组上进行汇总。</li>
<li>GROUP BY 子句中列出的每个列都必须是检索列或有效的表达式。（但不能是聚集函数）。如果在 SELECT 中使用表达式，则必须在 GOURP BY 子句中指定相同的表达式。不能使用别名。</li>
<li>除聚集计算语句外，SELECT 语句中的每个列都必须在 GOURP BY 子句中给出。</li>
<li>如果分组列中具有 NULL 值，则 NULL 将作为一个分组返回。如果列中有多行 NULL 值，它们将分为一组。</li>
<li>GOURP BY 子句必须出现在 WHERE 子句之后，ORDER BY 子句之前。</li>
</ul>
</li>
</ul>
<pre><code class="SQL">// WITH ROLLUP 关键字，可以得到每个分组以及每个分组汇总级别（针对每个分组）的值
SELECT vend_id, COUNT(*) AS num_prods
FROM products
GROUP BY vend_id WITH ROLLUP;
</code></pre>
<h2 id="过滤分组"><a href="#过滤分组" class="headerlink" title="过滤分组"></a>过滤分组</h2><ul>
<li>HAVING 非常类似于 WHERE。事实上，目前为止所有学过的所有类型的 WHERE 子句都可以用 HAVING 来替代。唯一的差别是 WHERE 过滤行，而 HAVING 过滤分组。</li>
<li>HAVING 支持所有 WHERE 操作符。</li>
</ul>
<pre><code class="SQL">SELECT cust_id, COUNT(*) AS orders
FROM orders
GROUP BY cust_id
HAVING COUNT(*) &gt;= 2;
</code></pre>
<ul>
<li>HAVING 和 WHERE 的差别：WHERE 在数据分组前进行过滤，HAVING 在数据分组后进行过滤。</li>
</ul>
<pre><code class="SQL">SELECT vend_id, COUNT(*) AS num_prods
FROM products
WHERE prod_price &gt;= 10
GROUP BY vend_id
HAVING COUNT(*) &gt;= 2;
</code></pre>
<h2 id="分组和排序"><a href="#分组和排序" class="headerlink" title="分组和排序"></a>分组和排序</h2><ul>
<li><p>ORDER BY</p>
<ul>
<li>排序产生的输出</li>
<li>任意列都可以使用（甚至非选择的列也可以使用）</li>
<li>不一定需要</li>
</ul>
</li>
<li><p>GROUP BY</p>
<ul>
<li>分组行。但输出可能不是分组的顺序</li>
<li>只可能使用选择列或表达式列，而且必须使用每个选择列表达式</li>
<li>如果与聚合函数一起使用列（或表达式），则必须使用</li>
</ul>
</li>
<li><p>一般在使用 GROUP BY 子句时，应该也给出 ORDER BY子句。这是保证数据正确排序的唯一方法。千万不要仅依赖 GROUP BY 排序数据。</p>
</li>
</ul>
<pre><code class="SQL">SELECT order_num, SUM(quantity * item_price) AS ordertotal
FROM orderitems
GROUP BY order_num
HAVING SUM(quantity * item_price) &gt;= 50
ORDER BY ordertotal;
</code></pre>
<h2 id="SELECT-子句顺序"><a href="#SELECT-子句顺序" class="headerlink" title="SELECT 子句顺序"></a>SELECT 子句顺序</h2><pre><code class="SQL">SELECT // 要返回的列或表达式 // 是
FROM // 从中检索数据的表 // 仅在从表选择数据时使用
WHERE // 行级过滤 // 否
GROUP BY // 分组说明 // 仅在按组计算聚集时使用
HAVING // 组级过滤 // 否
ORDER BY // 输出排序顺序 // 否
LIMIT // 要检索的行数 // 否
</code></pre>
<h1 id="使用子查询"><a href="#使用子查询" class="headerlink" title="使用子查询"></a>使用子查询</h1><ul>
<li>MySQL 4.1 引入对子查询的支持。</li>
</ul>
<h2 id="利用子查询进行过滤"><a href="#利用子查询进行过滤" class="headerlink" title="利用子查询进行过滤"></a>利用子查询进行过滤</h2><ul>
<li>在 SELECT 子句中，子查询总是从内向外处理。</li>
<li>格式化 SQL</li>
</ul>
<pre><code class="SQL">SELECT cust_name, cust_contact
FROM customers
WHERE cust_id IN (SELECT cust_id
                  FROM orders
                  WHERE order_num IN (SELECT order_num
                                     FROM orderitems
                                     WHERE prod_id = &#39;TNT2&#39;));
// 由于性能限制，不能嵌套太多的子查询。
</code></pre>
<h2 id="作为计算字段使用子查询"><a href="#作为计算字段使用子查询" class="headerlink" title="作为计算字段使用子查询"></a>作为计算字段使用子查询</h2><pre><code class="SQL">SELECT cust_name,
       cust_state,
       (SELECT COUNT(*)
        FROM orders
        WHERE orders.cust_id = customers.cust_id) AS orders
FROM customers
ORDER BY cust_name;
</code></pre>
<h1 id="联结表"><a href="#联结表" class="headerlink" title="联结表"></a>联结表</h1><h2 id="关系表"><a href="#关系表" class="headerlink" title="关系表"></a>关系表</h2><ul>
<li>外键（ foreign key ） 为某个表中的一列，它包含另一个表的主键值，定义了两个表的关系。</li>
</ul>
<h2 id="创建联结"><a href="#创建联结" class="headerlink" title="创建联结"></a>创建联结</h2><pre><code class="SQL">SELECT vend_name, prod_name, prod_price
FROM vendors, products
WHERE vendors.vend_id = products.vend_id
ORDER BY vend_name, prod_name;
</code></pre>
<ul>
<li>笛卡尔积（ cartesian product）由没有联结条件的表关系返回的结果。第一个表的行数乘以第二个表中的行数。</li>
</ul>
<h2 id="内部联结"><a href="#内部联结" class="headerlink" title="内部联结"></a>内部联结</h2><pre><code class="SQL">// 等值联结（ equijoin ），它基于两个表之间的相等测试。这种表称为内部联结
SELECT vend_name, prod_name, prod_price
FROM vendors INNER JOIN products
ON vendors.vend_id = products.vend_id; // 和前面 SELECT 语句相同

// ANSI SQL 规范首选 INNER JOIN 语法。
</code></pre>
<h2 id="联结多个表"><a href="#联结多个表" class="headerlink" title="联结多个表"></a>联结多个表</h2><pre><code class="SQL">SELECT prod_name, vend_name, prod_price, quantity
FROM orderitems, products, vendors
WHERE products.vend_id = vendors.vend_id
  AND orderitems.prod_id = products.prod_id
  AND order_num = 20005;

// MySQL 在运行时关联指定的每个表以处理联结。这种处理可能是非常耗费资源的。不要联结不必要的表。
// 联结的表越多，性能下降的越厉害。

SELECT cust_name, cust_contact
FROM customers
WHERE cust_id IN (SELECT cust_id
                  FROM orders
                  WHERE order_num IN (SELECT order_num
                                     FROM orderitems
                                     WHERE prod_id = &#39;TNT2&#39;));
// 子查询并不总是执行复杂 SELECT 操作的最有效的方法。
SELECT cust_name, cust_contact
FROM customers, orders, orderitems
ON customers.cust_id = orders.cust_id
  AND orders.order_num = orderitems.order_num
  AND prod_id = &#39;TNT2&#39;;
</code></pre>
<h1 id="创建高级联结"><a href="#创建高级联结" class="headerlink" title="创建高级联结"></a>创建高级联结</h1><h2 id="使用表别名"><a href="#使用表别名" class="headerlink" title="使用表别名"></a>使用表别名</h2><pre><code class="SQL">SELECT cust_name, cust_contact
FROM customers AS c, orders AS o, orderitems AS oi
WHERE c.cust_id = o.cust_id
  AND oi.order_num = o.order_num
  AND prod_id = &#39;TNT2&#39;;

// 表别名只在查询执行中使用。与列别名不一样，表别名不返回到客户机
</code></pre>
<h2 id="使用不同类型的联结"><a href="#使用不同类型的联结" class="headerlink" title="使用不同类型的联结"></a>使用不同类型的联结</h2><h3 id="自联结"><a href="#自联结" class="headerlink" title="自联结"></a>自联结</h3><pre><code class="SQL">SELECT prod_id, prod_name
FROM products
WHERE vend_id = (SELECT vend_id
                 FROM products
                 WHERE prod_id = &#39;DTNTR&#39;);
// 联结查询
SELECT p1.prod_id, p1.prod_name
FROM products AS p1, products AS p2
WHERE p1.vend_id = p2.vend_id
  AND p2.prod_id = &#39;DTNTR&#39;;

// 自联结通常作为外部语句用来替代从相同表中检索数据时使用的子查询语句。
// 有时候处理联结远比处理子查询快得多，应该尝试两种方法，确定哪一种性能更好。
</code></pre>
<h3 id="自然联结"><a href="#自然联结" class="headerlink" title="自然联结"></a>自然联结</h3><pre><code class="SQL">// 自然联结 排除多次出现，使每个列只返回一次。
// 一般通过对表中使用通配符（SELECT * ），对所有其他表的列使用明确的子集完成的。
SELECT c.*, o.order_num, o.order_date, oi.prod_id, oi.quantity, oi.item_price
FROM customers AS c, orders AS o, orderitems AS oi
WHERE c.cust_id = o.cust_id
  AND oi.order_num = o.order_num
  AND prod_id = &#39;FB&#39;;
</code></pre>
<h3 id="外部联结"><a href="#外部联结" class="headerlink" title="外部联结"></a>外部联结</h3><pre><code class="SQL">// 联结包含了那些在相关表中没有关联的行。

// 内联结
SELECT customers.cust_id, orders.order_num
FROM customers INNER JOIN orders
  ON customer.cust_id = orders.cust_id;

// 外部联结
SELECT customers.cust_id, orders.order_num
FROM customers LEFT OUTER JOIN orders
  ON customer.cust_id = orders.cust_id;
</code></pre>
<ul>
<li>MySQL 不支持简化字符 <code>*=</code> 和 <code>=*</code> 的使用，这两个操作符在其他 DBMS 中很流行</li>
</ul>
<h2 id="使用带聚集函数的联结"><a href="#使用带聚集函数的联结" class="headerlink" title="使用带聚集函数的联结"></a>使用带聚集函数的联结</h2><pre><code class="SQL">SELECT customers.cust_name,
       customers.cust_id,
       COUNT(orders.order_num) AS num_ord
FROM customers INNER JOIN orders
  ON customers.cust_id = orders.cust_id
GROUP BY customers.cust_id;

SELECT customers.cust_name,
       customers.cust_id,
       COUNT(orders.order_num) AS num_ord
FROM customers LEFT OUTER JOIN orders
  ON customers.cust_id = orders.cust_id
GROUP BY customers.cust_id;
</code></pre>
<h2 id="使用联结和联结条件"><a href="#使用联结和联结条件" class="headerlink" title="使用联结和联结条件"></a>使用联结和联结条件</h2><ul>
<li><p>要点</p>
<ul>
<li>注意所使用的联结类型</li>
<li>保证使用正确的联结条件，否则将返回不正确的数据</li>
<li>应该总是提供联结条件，否则会得出笛卡尔积</li>
<li>在一个联结中可以包含多个表，甚至对于每个联结可以采用不同的联结类型。记得分别测试每个联结</li>
</ul>
</li>
</ul>
<h1 id="组合查询"><a href="#组合查询" class="headerlink" title="组合查询"></a>组合查询</h1><ul>
<li>MySQL 也允许执行多个查询（多条 SELECT 语句），并将结果作为单个查询结果集返回。这些组合查询通常称为并（ union ）或复合查询（ compound query ）</li>
<li><p>需要使用组合查询</p>
<ul>
<li>在单个查询中从不同的表返回类似结构的数据</li>
<li>对单个表执行多个查询，按单个查询返回数据</li>
</ul>
</li>
<li><p>组合查询和多个 WHERE 条件，任何具有多个 WHERE 子句的 SELECT 语句都可以作为一个组合查询给出。这两种技术在不同的查询中性能也不同，因此，应该试一下，以确定对特定的查询哪一种性能更好。</p>
</li>
<li><p>可用 UNION 操作符来组合数条 SQL 查询。</p>
</li>
</ul>
<pre><code class="SQL">SELECT vend_id, prod_id, prod_price
FROM products
WHERE prod_price &lt;= 5;
UNION
SELECT vend_id, prod_id, prod_price
FROM products
WHERE vend_id IN (1001, 1002);
</code></pre>
<h2 id="UNION-规则"><a href="#UNION-规则" class="headerlink" title="UNION 规则"></a>UNION 规则</h2><ul>
<li>UNION 必须由两条或两条以上的 SELECT 语句组成，语句之间关键字 UNION 分隔。</li>
<li>UNION 的每个查询必须包含相同的列，表达式或聚集函数。（各个列不需要以相同的次序列出）</li>
<li>列数据类型必须兼容：类型不必完全相同，但必须是 DBMS 可以隐含地转换的类型</li>
</ul>
<h2 id="包含或取消重复的行"><a href="#包含或取消重复的行" class="headerlink" title="包含或取消重复的行"></a>包含或取消重复的行</h2><ul>
<li>UNION 从查询集中自动去除了重复的行。</li>
<li>UNION ALL 返回所有匹配行。</li>
</ul>
<h2 id="对组合查询结果排序"><a href="#对组合查询结果排序" class="headerlink" title="对组合查询结果排序"></a>对组合查询结果排序</h2><pre><code class="SQL">SELECT vend_id, prod_id, prod_price
FROM products
WHERE prod_price &lt;= 5
UNION
SELECT vend_id, prod_id, prod_price
FROM products
WHERE vend_id IN (1001, 1002)
ORDER BY vend_id, prod_price;

// 不允许使用多条 ORDER BY 子句
// 上面这个 SQL ，MySQL 将用它来排序所有 SELECT 语句返回的所有结果。
</code></pre>
<ul>
<li>使用 UNION 的组合查询也可以应用不同的表</li>
</ul>
<h1 id="全文本搜索"><a href="#全文本搜索" class="headerlink" title="全文本搜索"></a>全文本搜索</h1><ul>
<li>并非所有引擎都支持全文搜索。</li>
<li><p>MySQL 支持集中基本的数据库引擎。最常使用的引擎为 MyISAM 和 InnoDB 前者支持全文搜索，而后者不支持。</p>
</li>
<li><p>Like 关键字和正则搜索机制非常有用，但存在几个重要的限制</p>
<ul>
<li>性能，通配符和正则表达式匹配通常要求 MySQL 尝试匹配表中所有行（而且这些搜索极少使用表索引）。因此，由于被搜索行数不断增加，这些搜索可能非常耗时。</li>
<li>明确控制，使用通配符和正则表达式匹配，很难明确地控制匹配什么和不匹配什么。</li>
<li>智能化的结果，虽然基于通配符和正则表达式的搜索提供了非常灵活的搜索。但它们都不能提供一种智能化的选择结果的方法。</li>
</ul>
</li>
</ul>
<h2 id="使用全文本搜索"><a href="#使用全文本搜索" class="headerlink" title="使用全文本搜索"></a>使用全文本搜索</h2><ul>
<li>为了进行全文本搜索，必须索引被搜索到列，而且要随着数据的改变不断地重复索引。</li>
<li>在索引之后，SELECT 可与 Match() 和 Against() 一起使用以实际执行搜索。</li>
</ul>
<h3 id="启用全文本搜索支持"><a href="#启用全文本搜索支持" class="headerlink" title="启用全文本搜索支持"></a>启用全文本搜索支持</h3><pre><code class="SQL">// CREATE TABLE 语句接受 FULLTEXT 子句，它给出被索引列的一个逗号分隔的列表。
CREATE TABLE productnotes
(
    note_id int NOT NULL AUTO_INCREMENT,
    prod_id char(10) NOT NULL,
    note_date datetime NOT NULL,
    note_text text NULL,
    PRIMARY KEY(note_id),
    FULLTEXT(note_text)
) ENGINE=MyISM;
</code></pre>
<ul>
<li>在定义之后，MySQL 自动维护该索引。在增加，更新或删除行时，索引随之自动更新。</li>
<li>可以创建表时指定 FULLTEXT，或者在稍后指定（在这种情况下已有数据必须立即索引）</li>
<li>不要在导入数据时使用 FULLTEXT 。更新索引要花时间，虽然不是很多，但毕竟要花时间。如果正在导入数据到一个新表，应该首先导入所有数据，然后再修改表，定义 FULLTEXT。</li>
</ul>
<h3 id="进行全文本搜索"><a href="#进行全文本搜索" class="headerlink" title="进行全文本搜索"></a>进行全文本搜索</h3><pre><code class="SQL">// 在索引之后，使用两个函数 Match() 和 Against() 执行全文本搜索
// Match() 指定被搜索的列，Against() 指定要使用的搜索表达式。
SELECT note_text
FROM productnotes
WHERE Match(note_text) Against(&#39;rabbit&#39;);
</code></pre>
<ul>
<li><p>传递给 Match() 的值必须与 FULLTEXT() 定义中的相同。如果指定多个列，则必须列出它们（而且次序正确）</p>
</li>
<li><p>除非使用 BINARY 方式，否则全文本搜索不区分大小写。</p>
</li>
<li><p>不包含 ORDER BY 子句。使用 LIKE 以不特别有用的顺序返回数据。全文搜索返回以文本匹配的良好程度排序的数据。</p>
</li>
<li>全文搜索的一个重要部分就是对结果排序。具有较高等级的行先返回（因为这些是你真正想要的行）</li>
</ul>
<pre><code class="SQL">SELECT note_text,
       Match(note_text) Against(&#39;rabbit&#39;) AS rank
FROM productnotes;
// 返回所有行，rank 包含全文本搜索计算出的等级值。
// 等级由 MySQL 根据行中词的数目，唯一词的数目，整个索引中词的总数以及包含该词的行的数目计算出来。
// 文本中词靠前的行的等级值比词靠后的行的等级值高。
</code></pre>
<ul>
<li>如果指定多个搜索项，则包含多数匹配词的那些行将具有比包含较少词的那些行高的等级值。</li>
<li>由于数据是索引的，全文搜索还相当快。</li>
</ul>
<h3 id="使用查询扩展"><a href="#使用查询扩展" class="headerlink" title="使用查询扩展"></a>使用查询扩展</h3><ul>
<li><p>查询扩展用来设法放宽所返回的全文本搜索结果的范围。</p>
</li>
<li><p>MySQL 对数据和索引进行两遍扫描来完成搜索：</p>
<ul>
<li>首先，进行一个基本的全文本搜索，找出与搜索条件匹配的所有行</li>
<li>其次，MySQL 检查这些匹配行并选择所有有用的词</li>
<li>再其次，MySQL 再次进行全文本搜索，这次不仅使用原来的条件，而且还使用所有有用的词。</li>
</ul>
</li>
<li><p>利用查询扩展，能找出可能相关的结果，即使它们并不精确包含所查找的词。</p>
</li>
<li>查询扩展功能是在 MySQL 4.1.1 引入的。</li>
</ul>
<pre><code class="SQL">// 没有查询扩展
SELECT note_text
FROM productnotes
WHERE Match(note_text) Against(&#39;anvils&#39;);

// 查询扩展
SELECT note_text
FROM productnotes
WHERE Match(note_text) Against(&#39;anvils&#39;, WITH QUERY EXPANSION);
// 查询扩展极大地增加了返回的行数，但这样做也增加了你实际上并不想要的行的数目
</code></pre>
<ul>
<li>表中的行越多，使用查询扩展返回的结果越好</li>
</ul>
<h3 id="布尔文本搜索"><a href="#布尔文本搜索" class="headerlink" title="布尔文本搜索"></a>布尔文本搜索</h3><ul>
<li><p>布尔方式（boolean mode）</p>
<ul>
<li>要匹配的词</li>
<li>要排斥的词（如果某行包含这个词，则不返回该行，即使它包含其他指定的词也是如此）</li>
<li>排列提示（指定某些词比其他词更重要，更重要的词等级更高）</li>
<li>表达式分组</li>
<li>另外一些内容</li>
</ul>
</li>
<li><p>即使没有定义 FULLTEXT 索引，也可以使用布尔方式，但这是一种非常缓慢的操作（其性能随着数据量的增加而降低）</p>
</li>
</ul>
<pre><code class="SQL">// 使用 IN BOOLEAN MODE 但实际上没有指定布尔操作符
SELECT note_text
FROM productnotes
WHERE Match(note_text) Against(&#39;heavy&#39; IN BOOLEAN MODE);

SELECT note_text
FROM productnotes
WHERE Match(note_text) Against(&#39;heaby -rope*&#39; IN BOOLEAN MODE);
// -rope* 明确地指示 MySQL 排除任何以 rope 开始的词，包括 ropes 的行

// MySQL 4.x 中使用上面的例子不返回任何行，这是 * 操作符处理中的一个错误。修改 -rope* 为 -ropes。
</code></pre>
<ul>
<li><p>全文本布尔操作符</p>
<pre><code class="text">  +   包含，词必须存在
  -   排除，词必须不存在
  &gt;   包含，而且增加等级值
  &lt;   包含，且减少等级值
  ()  把词组成子表达式（允许这些子表达式作为一个组被包含，排除，排列等）
  ~   取消一个词的排序值
  *   词尾的通配符
  &quot;&quot;  定义一个短语（与单个词的列表不一样，它匹配整个短语以便包含或排出这个短语）
</code></pre>
</li>
</ul>
<pre><code class="SQL">SELECT note_text
FROM productnotes
WHERE Match(note_text) Against(&#39;+rabbit +bait&#39; IN BOOLEAN MODE);

SELECT note_text
FROM productnotes
WHERE Match(note_text) Against(&#39;rabbit bait&#39; IN BOOLEAN MODE);
// 搜索匹配至少包含一个词的行

SELECT note_text
FROM productnotes
WHERE Match(note_text) Against(&#39;&quot;rabbit bait&quot;&#39; IN BOOLEAN MODE);
// 搜索匹配短语 rabbit bait

SELECT note_text
FROM productnotes
WHERE Match(note_text) Against(&#39;&gt;rabbit &lt;carrot&#39; IN BOOLEAN MODE);

SELECT note_text
FROM productnotes
WHERE Match(note_text) Against(&#39;+safe +(&lt;combination)&#39; IN BOOLEAN MODE);
</code></pre>
<ul>
<li>在布尔方式中，不按等级值降序排序返回的行。</li>
</ul>
<h3 id="全文本搜索的使用说明"><a href="#全文本搜索的使用说明" class="headerlink" title="全文本搜索的使用说明"></a>全文本搜索的使用说明</h3><ul>
<li>在索引全文本数据时，短词被忽略且从索引中排除。短词定义为那些具有 3 个或 3 个以下字符的词（如果需要，这个数目可以更改）</li>
<li>MySQL 带有一个内建的非用词（stopword）列表，这些词在索引全文本数据时总是被忽略。（如果需要可以覆盖这个列表）</li>
<li>许多词出现的频率很高，搜索他们没有用处（返回太多的结果）。因此，MySQL 规定了一条 50% 规则，如果一个词出现在 50% 以上的行中，则将它作为一个非用词忽略。 50% 的规则不用于 IN BOOLEAN MODE</li>
<li>如果表中的行数少于 3 行，则全文本搜索的不返回结果（因为每个词或者不出现，或者至少出现在 50% 的行中）</li>
<li>忽略词中的单引号。</li>
<li>不具有词分隔符的语言不能恰当地返回全文本搜索结果。</li>
<li><p>如前所述，仅在 MyISAM 数据库引擎中支持全文本搜索。</p>
</li>
<li><p>MySQL 全文本搜索现在还不支持邻近操作符。（搜索相邻的词）</p>
</li>
</ul>
<h1 id="插入数据"><a href="#插入数据" class="headerlink" title="插入数据"></a>插入数据</h1><h2 id="数据插入"><a href="#数据插入" class="headerlink" title="数据插入"></a>数据插入</h2><ul>
<li><p>插入的几种方式</p>
<ul>
<li>插入完整的行</li>
<li>插入行的一部分</li>
<li>插入多行</li>
<li>插入某些查询的结果</li>
</ul>
</li>
<li><p>可针对每个表或每个用户，利用  MySQL 的安全机制禁止使用 INSERT 语句</p>
</li>
</ul>
<h2 id="插入完整的行"><a href="#插入完整的行" class="headerlink" title="插入完整的行"></a>插入完整的行</h2><pre><code class="SQL">INSERT INTO Customers 
VALUES(NULL,
       &#39;Pep E. LaPew&#39;,
       &#39;Los Angeles&#39;,
       &#39;CA&#39;,
       &#39;90046&#39;,
       &#39;USA&#39;,
       NULL,
       NULL);

// 必须给出每个列，各个列必须以它们在表定义中出现的次序填充。
// 某个列没有值，应该使用 NULL 值。
// 主键也为 NULL ，由 MySQL 自动增量。不能省略此列
// 不安全，尽量避免使用，上面的 SQL 高度依赖于表中列的定义次序，并且还依赖于其次序容易获得的消息。
</code></pre>
<ul>
<li>INSERT 语句一般不会产生输出。</li>
</ul>
<pre><code class="SQL">INSERT INTO customers(cust_name,
    cust_address,
    cust_city,
    cust_state,
    cust_zip,
    cust_country,
    cust_contact,
    cust_email)
VALUES(&#39;Pep E, LaPew&#39;,
    &#39;100 Main Street&#39;,
    &#39;Los Angeles&#39;,
    &#39;CA&#39;,
    &#39;90046&#39;,
    &#39;USA&#39;,
    NULL,
    NULL);

// VALUES 必须以指定次序匹配指定的列名。
// 不需要设置主键的 NULL 值。
</code></pre>
<ul>
<li>一般不要使用没有明确给出列的列表的 INSERT 语句。使用列的列表能使 SQL 代码继续发挥作用，即使表结构发生了变化。</li>
<li><p>不管使用哪种 INSERT 语法，都必须给出 VALUES 的正确数目。</p>
</li>
<li><p>如果表的定义允许，则可以在 ISNERT 操作中省略某些列。</p>
<ul>
<li>该列定义为允许 NULL 值（无值或空值）</li>
<li>在表定义中给出默认值。这表示如果不给出值，将使用默认值。</li>
</ul>
</li>
<li><p>数据库经常被多个客户访问，对处理什么请求以及用什么次序处理进行管理时 MySQL 的任务。INSERT 操作可能很耗时（特别是有很多索引需要更新时），而且它可能降低等待处理的 SELECT 语句的性能。</p>
</li>
<li>如果数据检索是最重要的，则你可以通过在 INSERT 和 INTO 之间添加关键字 LOW_PRIORITY ，指示 MySQL 降低 INSERT 语句的优先级 <code>INSERT  LOW_PRIORITY INTO</code> 也适用于 UPDATE 和 DELETE 语句。</li>
</ul>
<h2 id="插入多个行"><a href="#插入多个行" class="headerlink" title="插入多个行"></a>插入多个行</h2><pre><code class="SQL">// 使用多条 INSERT 语句
// 或者
INSERT INTO customers(cust_name,
    cust_address,
    cust_city,
    cust_state,
    cust_zip,
    cust_country)
VALUES(
    &#39;Pep E. LaPew&#39;,
    &#39;100 Main Street&#39;,
    &#39;Los Angeles&#39;,
    &#39;CA&#39;,
    &#39;90046&#39;,
    &#39;USA&#39;
), (
    &#39;M. Martian&#39;,
    &#39;42 Galaxy Way&#39;,
    &#39;New Yorw&#39;,
    &#39;NY&#39;,
    &#39;11213&#39;,
    &#39;USA&#39;
);
// 单条 INSERT 语句有多组值，每组值用一对圆括号括起来，用逗号分隔。
// 次技术可以提高数据库处理的性能，因为 MySQL 用单条 INSERT 语句处理多个插入比使用多条 INSERT 语句快。
</code></pre>
<h2 id="插入检索出的数据"><a href="#插入检索出的数据" class="headerlink" title="插入检索出的数据"></a>插入检索出的数据</h2><ul>
<li>假如你想从另一个表中合并客户列表到你的 customers 表。不需要每次读取一行，然后再将它用 <code>INSERT</code> 插入。</li>
<li>合并表时，不应该使用当前表中使用过的主键值或仅省略这列值让 MySQL 在导入数据的过程中产生新值。</li>
</ul>
<pre><code class="SQL">INSERT INTO customers(cust_id,
    cust_contact,
    cust_email,
    cust_name,
    cust_address,
    cust_city,
    cust_state,
    cust_zip,
    cust_country)
SELECT cust_id,
    cust_contact,
    cust_email,
    cust_name,
    cust_address,
    cust_city,
    cuts_state,
    cust_zip,
    cust_country)
FROM custnew;
// 这里假设 cust_id 的值不重复，也可以省略
// INSERT 和 SELECT 语句中使用了相同的列名，但是不一定要求列名匹配
// 事实上，MySQL 甚至不关心 SELECT 返回的列名，它使用的是列的位置，SELECT 中的第一列（不管其列名）将用来填充表列中指定的第一个列
// 这对于从使用不同列名的表中导入数据是非常有用的。
// INSERT SELECT 中的 SELECT 语句可包含 WHERE 子句以过滤插入的数据。
</code></pre>
<h1 id="更新和删除数据"><a href="#更新和删除数据" class="headerlink" title="更新和删除数据"></a>更新和删除数据</h1><h2 id="更新数据"><a href="#更新数据" class="headerlink" title="更新数据"></a>更新数据</h2><ul>
<li><p>采用两种方式使用 UPDATE：</p>
<ul>
<li>更新表中特定行</li>
<li>更新表中所有行</li>
</ul>
</li>
<li><p>在使用 UPDATE 时一定要注意细心，因为稍不注意，就会更新表中所有行，不要省略 WHERE 子句。</p>
</li>
<li>可以限制和控制 UPDARTE 语句的使用</li>
<li><p>UPDATE 组成部分</p>
<ul>
<li>要更新的表</li>
<li>列名和它们的新值</li>
<li>确定要更新行的过滤条件</li>
</ul>
</li>
</ul>
<pre><code class="SQL">UPDATE customers
SET cust_email = &#39;elmer@fudd.com&#39;
WHERE cust_id = 10005;

UPDATE customers
SET cust_name = &#39;THE Fudds&#39;
    cust_email = &#39;elmer@fudd.com&#39;
WHERE cust_id = 10005;
</code></pre>
<ul>
<li>UPDATE 语句中可以使用子查询，使得能用 SELECT 语句检索出的数据更新列数据。</li>
<li>如果 UPDATE 语句更新多行，更新这些行中的一行或多行出一个错误，则整个 UPDATE 操作被取消。为即使是发生错误，也继续更新可以使用 IGNORE 关键字 <code>UPDATE IGNORE customers...</code></li>
</ul>
<pre><code class="SQL">// 为了删除某个列的值，可设置它为 NULL（假定表定义允许 NULL 值）
UPDATE customers
SET cust_email = NULL,
WHERE cust_id = 10005;
</code></pre>
<h2 id="删除数据"><a href="#删除数据" class="headerlink" title="删除数据"></a>删除数据</h2><ul>
<li><p>使用方式</p>
<ul>
<li>从表中删除特定的行</li>
<li>从表中删除所有行</li>
</ul>
</li>
<li><p>不要省略 WHERE 子句</p>
</li>
<li>可以限制和控制 DELETE 语句的使用</li>
</ul>
<pre><code class="SQL">DELETE FROM customers
WHERE cust_id = 10006;
//  DELETE 删除整行而不是删除列，为了删除指定的列，使用 UPDATE 语句
</code></pre>
<ul>
<li>如果要删除所有行，不要使用 <code>DELETE</code>。使用更快的 <code>TRUNCATE TABLE</code>  语句（TRUNCATE 实际上是删除原来的表并重新创建一个表，而不是逐行删除表中的数据）</li>
</ul>
<h2 id="更新和删除的指导原则"><a href="#更新和删除的指导原则" class="headerlink" title="更新和删除的指导原则"></a>更新和删除的指导原则</h2><ul>
<li><p>遵循的习惯</p>
<ul>
<li>除非确实打算更新和删除每一行，否则绝对不要使用不带 WHERE 子句的 UPDATE 或 DELETE语句</li>
<li>保证每个表都有主键，尽可能像 WHERE 子句那样使用它（可以指定各主键，多个值或值的范围）</li>
<li>在对 UPDATE 或 DELETE 语句使用 WHERE子句前，应该先用 SELECT 进行测试，保证它过滤的是正确的记录，以防编写的 WHERE 子句不正确。</li>
<li>使用强制实施引用完整性的数据库，这样 MySQL 将不允许删除具有与其他表相关联的数据的行。</li>
<li>MySQl 没有撤销（undo）按钮。应该非常小心地使用 UPDATE 和 DELTE。</li>
</ul>
</li>
</ul>
<h1 id="创建和操纵表"><a href="#创建和操纵表" class="headerlink" title="创建和操纵表"></a>创建和操纵表</h1><h2 id="创建表"><a href="#创建表" class="headerlink" title="创建表"></a>创建表</h2><ul>
<li><p>创建表的方法</p>
<ul>
<li>使用具有交互式的创建和管理表的工具</li>
<li>表也可以直接 MySQL 语句操纵</li>
</ul>
</li>
</ul>
<h3 id="表创建基础"><a href="#表创建基础" class="headerlink" title="表创建基础"></a>表创建基础</h3><ul>
<li><p>利用 CREATE TABLE 创建表，必须给出信息：</p>
<ul>
<li>新表的名字，在关键字 CREATE TABLE 之后给出</li>
<li>表列的名字和定义，用逗号分隔</li>
</ul>
</li>
</ul>
<pre><code class="SQL">CREATE TABLE customers
(
    cust_id      int        NOT NULL AUTO_INCRMENT,
    cust_name    char(50)   NOT NULL,
    cust_address char(50)   NULL,
    cust_city    char(50)   NULL,
    cust_state   char(5)    NULL,
    cust_zip     char(10)   NULL,
    cust_country char(50)   NULL,
    cust_contact char(50)   NULL,
    cust_email   char(255)  NULL,
    PRIMARY KEY (cust_id)  
) ENGINE=InnoDB;
// 语句格式化  MySQL 语句中忽略空格
// 创建表时，指定的表名必须不存在。在表名后给出 `IF NOT EXISTS`
</code></pre>
<h3 id="使用-NULL-值"><a href="#使用-NULL-值" class="headerlink" title="使用 NULL 值"></a>使用 NULL 值</h3><ul>
<li><code>NULL</code> 值就是没有值或缺值。允许 NULL 值的列也允许在插入行时不给出该列的值。不允许 NULL 值的列不接受该列没有值的行，在插入或更新行时，该列必须有值。</li>
</ul>
<pre><code class="SQL">CREATE TABLE orders
(
    order_num   int         NOT NULL AUTO_INCREMENT,
    order_date  datetime    NOT NULL,
    cuts_id     int         NOT NULL,
    PRIMARY KEY(order_num)
) ENGINE=InnoDB;
// NULL 为默认设置，如果不指定 NOT NULL，则认为指定的是 NULL
</code></pre>
<ul>
<li>不要把 NULL 值与空串相混淆。空串是一个有效的值</li>
</ul>
<h2 id="主键再介绍"><a href="#主键再介绍" class="headerlink" title="主键再介绍"></a>主键再介绍</h2><ul>
<li>主键值必须唯一。</li>
</ul>
<pre><code class="SQL">CREATE TABLE orderitems
(
    order_num   int         NOT NULL，
    order_item  int         NOT NULL,
    prod_id     char(10)    NOT NULL,
    quantity    int         NOT NULL,
    item_price  decimal(8,2)NOT NULL,
    PRIMARY KEY(order_num, order_item)
) ENGINE=InnoDB;
</code></pre>
<ul>
<li>主键可以在创建表时定义，或者在创建表之后定义</li>
<li>主键中只能使用不允许 NULL 值的列。允许 NULL 值的列不能作为唯一标识。</li>
</ul>
<h3 id="使用-AUTO-INCREMENT"><a href="#使用-AUTO-INCREMENT" class="headerlink" title="使用 AUTO_INCREMENT"></a>使用 AUTO_INCREMENT</h3><ul>
<li>每个表允许一个 AUTO_INCREMENT 列，而且它必须被索引（如，通过使它成为主键）</li>
<li>覆盖 AUTO_INCREMENT 。可以简单地在 INSERT 语句中指定一个值，只要它是唯一的即可，该值将被用来替代自动生成的值。后续的增量将开始使用该手工插入的值。</li>
<li>让 MySQL 生成（通过自动增量）主键的一个缺点时你不知道这些值都是谁。</li>
</ul>
<pre><code class="SQL">// 使用
last_insert_id() // 函数获得这个值
SELECT last_insert_id()
// 此语句返回最后一个 AUTO_INCREMENT 值，然后可以将它用于后续的 MySQL 语句
</code></pre>
<h3 id="指定默认值"><a href="#指定默认值" class="headerlink" title="指定默认值"></a>指定默认值</h3><pre><code class="SQL">// 插入行没有给出值，MySQL 允许指定此时使用的默认值
CREATE TABLE orderitems
(
    order_num   int     NOT NULL,
    order_item  int     NOT NULL,
    quantity    char(10)NOT NULL DEFAULT 1,
    item_price  decimal(8, 2)NOT NULL,
    PRIMARY KEY (order_num, order_item)
) ENGINE=InnDB;
</code></pre>
<ul>
<li>与大多数 DBMS 不一样，MySQL 不允许使用函数作为默认值，它只支持常量。</li>
<li>使用默认值而不是 NULL 值，特别是对用于计算或数据分组的列更是如此。</li>
</ul>
<h3 id="引擎类型"><a href="#引擎类型" class="headerlink" title="引擎类型"></a>引擎类型</h3><ul>
<li>MySQL 有一个具体管理和处理数据的内部引擎。在使用 CREATE TABLE 语句时，该引擎具体创建表，而在你使用 SELECT 语句或进行其他数据库处理时，该引擎在内部处理你的请求。</li>
<li>但 MySQL 与其他 DBMS 不一样，它具有多种引擎。它打包多个引擎，这些引擎都隐藏在 MySQL 服务器内，全都能执行 CREATE TABLE 和 SELECT 等命令。</li>
<li>如果省略 <code>ENGINE=</code> 语句，则使用默认引擎（很可能是 MyISAM），多数 SQL 语句都会默认使用它。但并不是所有语句都默认使用它，这就是为什么 <code>ENGINE=</code> 语句。</li>
<li><p>需要知道的引擎</p>
<ul>
<li>InnoDB 是一个可靠的事务处理引擎，它不支持全文本搜索。</li>
<li>MEMORY 在功能上等同于 MyISAM，但由于数据存储在内存（不是磁盘）中，速度很快（特别适合临时表）</li>
<li>MyISAM 是一个性能极高的引擎，它支持全文本搜索，但不支持事务处理。</li>
</ul>
</li>
<li><p>引擎类型可以混用。</p>
</li>
<li>混用引擎类型有一个大缺陷。外键（用于强制实施引用完整性）不能跨引擎，即使用一个引擎的表不能引用具有使用不同引擎的表的外键</li>
</ul>
<h2 id="更新表"><a href="#更新表" class="headerlink" title="更新表"></a>更新表</h2><ul>
<li>更新表定义，可使用 ALTER TABLE 语句。但是，理想状态下，当表中存储数据以后，该表就不应该再被更新。</li>
<li><p>更改表结构，必须给出下面的消息：</p>
<ul>
<li>在 ALTER TABLE 之后给出要更改的表名</li>
<li>所做更改的列表</li>
</ul>
</li>
</ul>
<pre><code class="SQL">// 增加一个列
ALTER TABLE vendors
ADD vend_phone CHAR(20);

// 删除添加的列
ALTER TABLE vendors
DROP COLUMN vend_phone;
</code></pre>
<ul>
<li>ALTER TABLE 的一种常见用途是定义外键。</li>
</ul>
<pre><code class="SQL">ALTER TABLE orderitems
ADD CONSTRAINT fk_orderitems_orders
FOREIGN KEY (order_num) 
REFERENCES orders (order_num);

ALTER TABLE orderitems
ADD CONSTRAINT fk_orderitems_products
FOREIGN KEY (prod_id) 
REFERENCES products(prod_id);

ALTER TABLE orders
ADD CONSTRAINT fk_orders_customers
FOREIGN KEY (cust_id)
REFERENCES customers (cust_id);

ALTER TABLE products
ADD CONSTRAINT fk_products_vendors
FOREIGN KEY (vend_id)
REFERENCES vendors (vend_id);
</code></pre>
<ul>
<li>对单个表进行多个更改，可以使用单条 ALTER TABLE 语句，每个更改用逗号分隔。</li>
<li><p>复杂的表结构更改一般需要手动删除过程，涉及步骤</p>
<ul>
<li>用新的列布局创建一个新表</li>
<li>使用 INSERT SELECT 语句从旧表复制数据到新表。如果有必要，可使用转换函数和计算字段</li>
<li>检验包含所需数据到新表</li>
<li>重命名旧表</li>
<li>用旧表原来的名字重命名新表</li>
<li>根据需要，重新创建触发器，存储过程，索引和外键</li>
</ul>
</li>
<li><p>使用 ALTER TABLE 要极为小心，应该在进行改动前做一个完整的备份（模型和数据的备份）数据库表的更改不能撤销。</p>
</li>
</ul>
<h2 id="删除表"><a href="#删除表" class="headerlink" title="删除表"></a>删除表</h2><pre><code class="SQL">DROP TABLE customers2;
// 删除表没有确认，也不能撤销，执行这条语句将永久删除该表
</code></pre>
<h2 id="重命名表"><a href="#重命名表" class="headerlink" title="重命名表"></a>重命名表</h2><pre><code class="SQL">// 重命名一个表
RENAME TABLE customers2 TO customers;

// 重命名多个表
RENAME TABLE backup_customer TO customers,
             backup_vendors TO vendors,
             backup_products TO products;
</code></pre>
<h1 id="使用视图"><a href="#使用视图" class="headerlink" title="使用视图"></a>使用视图</h1><h2 id="视图"><a href="#视图" class="headerlink" title="视图"></a>视图</h2><ul>
<li>MySQL 5 添加了对视图的支持。</li>
<li>视图是虚拟的表。与包含数据的表不一样，视图只包含使用时动态检索数据的查询 。</li>
</ul>
<pre><code class="SQL">SELECT cust_name, cust_contact
FROM cusstomers, orders, orderitems
WHERE customers.cust_id = orders.cust_id
  AND orderitems.order_num = orders.order_num
  AND prod_id = &#39;TNT2&#39;;

SELECT cust_name, cust_contact
FROM productcustomers
WHERE prod_id = &#39;TNT2&#39;;
</code></pre>
<h3 id="为什么使用视图"><a href="#为什么使用视图" class="headerlink" title="为什么使用视图"></a>为什么使用视图</h3><ul>
<li><p>常见应用</p>
<ul>
<li>重用 SQL 语句</li>
<li>简化复杂的 SQL 操作。在编写查询后，可以方便地重用它而不必知道它的基本查询细节</li>
<li>使用表的组成部分而不是整个表</li>
<li>保护数据。可以给用户授予表的特定部分的访问权限而不是整个表的访问权限。</li>
<li>更改数据格式和表示。视图可返回与底层表的表示和格式不同的数据</li>
</ul>
</li>
<li><p>视图本身不包含数据，因此它们返回的数据是从其他表中检索出来的。在添加或更改这些表中的数据时，视图将返回改变过的数据。</p>
</li>
<li>因为视图不包含数据。所以每次使用视图时，都必须处理查询执行时所需的任一检索。如果你用多个联结和过滤创建了复杂的视图或者嵌套了视图，可能会发现性能下降得很厉害。因此，在部署使用了大量视图的应用前，应该进行测试。</li>
</ul>
<h3 id="视图的规则和限制"><a href="#视图的规则和限制" class="headerlink" title="视图的规则和限制"></a>视图的规则和限制</h3><ul>
<li><p>最常见的规则和限制</p>
<ul>
<li>与表一样，视图必须唯一命名。</li>
<li>对于可以创建的视图数目没有限制。</li>
<li>为了创建视图，必须具有足够的访问权限。这些限制通常由数据库管理人员授予。</li>
<li>视图可以嵌套，即可以利用从其他视图中检索数据的查询来构造一个视图。</li>
<li>ORDER BY 可以用在视图中，但如果从该视图检索数据 SELECT 中也含有 ORDER BY ，那么该视图中的 ORDER BY 将被覆盖。</li>
<li>视图不能索引，也不能有关联的触发器或默认值。</li>
<li>视图可以和表一起使用。</li>
</ul>
</li>
</ul>
<h2 id="视图-1"><a href="#视图-1" class="headerlink" title="视图"></a>视图</h2><ul>
<li><p>视图的创建</p>
<ul>
<li>视图用 CREATE VIEW 语句来创建</li>
<li>使用 SHOW CREATE VIEW viewname; 来查看创建视图的语句。</li>
<li>用 DROP 删除视图，其语法为 DROP VIEW viewname;</li>
<li>更新视图时，可以先用 DROP 再用 CREATE ，也可以直接用 CREATE OR REPLACE VIEW.</li>
</ul>
</li>
</ul>
<h3 id="利用视图简化复杂的联结"><a href="#利用视图简化复杂的联结" class="headerlink" title="利用视图简化复杂的联结"></a>利用视图简化复杂的联结</h3><pre><code class="SQL">CREATE VIEW productcustomers AS
SELECT cust_name, cust_contact, prod_id
FROM customers, orders, orderitems
WHERE customers.cust_id = orders.cust_id
  AND orderitems.order_num = orders.order_num;

SELECT cust_name, cust_contact
FROM productcustomers
WHERE prod_id = &#39;TNT2&#39;;

// 它将指定的 WHERE 子句添加到视图查询中的已有 WHERE 子句中，以便正确过滤数据。
</code></pre>
<ul>
<li>创建不受特定数据限制的视图时一种好办法。</li>
</ul>
<h3 id="用视图重新格式化检索出的数据"><a href="#用视图重新格式化检索出的数据" class="headerlink" title="用视图重新格式化检索出的数据"></a>用视图重新格式化检索出的数据</h3><ul>
<li>视图另一个常见用途是重新格式化检索出的数据。</li>
</ul>
<pre><code class="SQL">SELECT Concat(RTrim(vend_name), &#39;(&#39;, RTrim(vend_country), &#39;)&#39;) AS vend_title
FROM vendors
ORDER BY vend_name;

CREATE VIEW vendorlocations AS
SELECT Concat(RTrim(vend_name), &#39;(&#39;, RTrim(vend_country), &#39;)&#39;) AS vend_title
FROM vendors
ORDER BY vend_name;

SELECT *
FROM vendorlocations;
</code></pre>
<h3 id="用视图过滤不想要的数据"><a href="#用视图过滤不想要的数据" class="headerlink" title="用视图过滤不想要的数据"></a>用视图过滤不想要的数据</h3><pre><code class="SQL">CREATE VIEW customeremaillist AS
SELECT cust_id, cust_name, cust_email
FROM customers
WHERE cust_email IS NOT NULL;
</code></pre>
<h3 id="使用视图与计算字段"><a href="#使用视图与计算字段" class="headerlink" title="使用视图与计算字段"></a>使用视图与计算字段</h3><pre><code class="SQL">CREATE VIEW orderitemsexpanded AS
SELECT order_num,
       prod_id,
       quantity,
       item_price,
       quantity*item_price AS expanded_price
FROM orderitems;

SELECT *
FROM orderitemsexpanded
WHERE order_num = 20005;
</code></pre>
<h3 id="更新视图"><a href="#更新视图" class="headerlink" title="更新视图"></a>更新视图</h3><ul>
<li>更新一个视图将更新其基表。</li>
<li>如果 MySQL 不能正确地确定被更新的基数据，则不允许更新（插入，删除）。</li>
<li><p>如果视图定义中有以下操作，则不能进行视图的更新：</p>
<ul>
<li>分组（使用 GROUP BY 和 HAVING）</li>
<li>联结</li>
<li>子查询</li>
<li>并</li>
<li>聚集函数（Min(),Count(),Sum()）</li>
<li>DISTINCT</li>
<li>导出</li>
</ul>
</li>
<li><p>上面的限制自 MySQL 5以来是正确的。不过，未来的 MySQL 很可能会取消某下限制。</p>
</li>
<li><p>一般，应该将视图用于检索（SELECT 语句）而不用于更新（INSERT,UPDATE,DELETE）</p>
</li>
<li><p>视图提供了一种哦 MySQL 的 SELECT 语句层次的封装，可用来简化数据处理以及重新格式化基础数据或保护基础数据。</p>
</li>
</ul>
<h1 id="使用存储过程"><a href="#使用存储过程" class="headerlink" title="使用存储过程"></a>使用存储过程</h1><h2 id="存储过程"><a href="#存储过程" class="headerlink" title="存储过程"></a>存储过程</h2><ul>
<li>MySQL 5 添加了对存储过程的支持。</li>
</ul>
<h2 id="为什么要使用存储过程"><a href="#为什么要使用存储过程" class="headerlink" title="为什么要使用存储过程"></a>为什么要使用存储过程</h2><ul>
<li><p>主要的理由</p>
<ul>
<li>通过把处理封装在容易使用的单元中，简化复杂的操组。</li>
<li>由于不要求反复建立一系列处理步骤，这保证了数据的完整性。防止错误，需要执行的步骤越多，出错的可能性就越大。防止错误保证了数据的一致性。</li>
<li>简化对变动的管理。如果表名，列名或业务逻辑有变化，只需要更改存储过程的代码。使用它的人员甚至不需要知道这些变化。这一点是安全性。通过存储过程限制对基础数据的访问减少了数据讹误的机会。</li>
<li>提高性能。使用存储过程比使用单独的 SQL 语句要快</li>
<li>存在一些只能用在单个请求中的 MySQL 元素和特性，存储过程可以使用它们来编写功能更强更灵活的代码。</li>
</ul>
</li>
<li><p>简单，安全，高性能。缺陷</p>
<ul>
<li>一般来说，存储过程的编写比基本 SQL 语句复杂，编写存储过程需要更高的技能，更丰富的经验。</li>
<li>没有创建存储过程的安全访问权限。</li>
</ul>
</li>
</ul>
<h2 id="使用存储过程-1"><a href="#使用存储过程-1" class="headerlink" title="使用存储过程"></a>使用存储过程</h2><h3 id="执行存储过程"><a href="#执行存储过程" class="headerlink" title="执行存储过程"></a>执行存储过程</h3><ul>
<li>MySQL 称存储过程的执行为调用，因此 MySQL 执行存储过程的语句为 CALL。CALL 接受存储过程的名字以及需要传递给它的任意参数。</li>
</ul>
<pre><code class="SQL">CALL productpricing(
        @pricelow,
        @pricehigh,
        @priceaverage
);
</code></pre>
<h3 id="创建存储过程"><a href="#创建存储过程" class="headerlink" title="创建存储过程"></a>创建存储过程</h3><pre><code class="SQL">CREATE PROCEDURE productpricing()
BEGIN
    SELECT Avg(prod_price) AS priceaverage
    FROM products;
END;
</code></pre>
<ul>
<li>MySQL 命令行客户机的分隔符</li>
</ul>
<pre><code class="SQL">// MySQL 命令行也使用 &#39;;&#39; 字符，则它们最终不会成为存储过程的成分，这会使用存储过程中的 SQL 出现句法错误。
// 解决办法是临时更改命令行实用程序的语句分隔符。

DELIMITER //
CREATE PROCEDURE productpricing()
BEGIN
    SELECT Avg(prod_price) AS priceaverage
    FROM products;
END //

DELIMITER ;

// 除了  `\` 符号外，任何字符都可以用作语句分隔符。
// 使用
CALL productpricing();
// 执行刚创建的存储过程并显示返回的结果。因为存储过程是一种函数，所以存储过程名后需要有（）符号。
</code></pre>
<h3 id="删除存储过程"><a href="#删除存储过程" class="headerlink" title="删除存储过程"></a>删除存储过程</h3><pre><code class="SQL">DROP PROCEDURE productpricing;
// 没有使用后面的()，只给出存储过程名。

DROP PROCEDURE IF EXISTS
</code></pre>
<h3 id="使用参数"><a href="#使用参数" class="headerlink" title="使用参数"></a>使用参数</h3><ul>
<li>一般，存储过程并不显示结果，而是把结果返回给你指定的变量。</li>
<li>变量（variable）内存中一个特定的位置，用来临时存储数据。</li>
</ul>
<pre><code class="SQL">CREATE PROCEDURE productpricing(
    OUT pl DECIMAL(8, 2),
    OUT ph DECIMAL(8, 2),
    OUT pa DECIMAL(8, 2)
)
BEGIN
    SELECT Min(prod_price)
    INTO pl
    FROM products;
    SLECT Max(prod_price)
    INTO ph
    FROM products;
    SELECT Avg(prod_price)
    INTO pa
    FROM products;
END;
// 此存储过程接受 3 个参数。每个参数必须具有指定的类型，这里使用十进制值。
// 关键字 OUT 指出相应的参数用来从存储过程传出一个值（返回给调用者）。
// MySQL 支持 IN （传递给存储过程），OUT （从存储过程传出）和 INOUT （对存储过程传入和传出）类型的参数。
// 存储过程的代码位于 BEGIN 和 END 语句内。一系列 SELECT 语句，用来检索值，然后保存到相应的变量（通过指定 INTO 关键字）
</code></pre>
<ul>
<li>存储过程的参数允许的数据类型与表中使用的数据类型相同。</li>
<li>记录集不是允许的类型，因此，不能通过一个参数返回多个行和列。</li>
</ul>
<pre><code class="SQL">CALL productpricing(
    @pricelow,
    @pricehigh,
    @priceaverage
);
// 所有 MySQl 变量都必须以 @ 开始。
// 在调用时，这条语句并不显示任何数据。它返回以后可以显示的变量。
SELECT @priceaverage;
SELECT @pricehigh, @pricelow, @priceaverage

CREATE PROCEDURE ordertotal(
    IN onumber INT,
    OUT ototal DECIMAL(8,2)
)
BEGIN
    SELECT Sum(item_price*quantity)
    FROM orderitems
    INTO ototal;
END;

CALL ordertotal(20005, @total);
SELECT @total;
</code></pre>
<h3 id="建立智能存储过程"><a href="#建立智能存储过程" class="headerlink" title="建立智能存储过程"></a>建立智能存储过程</h3><ul>
<li>只有在存储过程内包含业务规则和智能处理时，它们的威力才真正显现出来。</li>
</ul>
<pre><code class="SQL">-- Name: ordertotal
-- Parameters: onumber = order number
--             taxable = 0 if not taxable, 1 if taxable
--             ototal = order total variable

CREATE PROCEDURE ordertotal(
    IN onumber INT,
    IN taxable BOOLEAN,
    OUT ototal DECIMAL(8,2)
) COMMENT &#39;Obtain order total, optionally adding tax&#39;

-- Declare variable for total
DECLARE total DECIMAL(8,2);
-- Declare tax percentage
DECLARE taxrate INT DEFAULT 6;

-- Get the order total
SELECT Sum(item_price*quantity)
FROM orderitems
WHERE order_num = onumber
INTO total;

-- Is this taxable?
IF taxable THEN
    -- Yes, so add taxrate to the total
    SELECT total+(total/100*taxtate) INTO total;
END IF;
    -- And finally, save to out variable
    SELECT total INTO ototal;
END;

// -- 注释
// DECLARE 语句定义了两个局部变量。DECLARE 要求指定变量名和数据类型
// COMMENT 值，它不必需的，但如果给出，将在 SHOW PROCEDURE STATUS 的结果中显示。

CALL ordertotal(20005, 0, @total);
SELECT @total;
CALL ordertotal(20005, 1, @total);
SELECT @total;
</code></pre>
<h3 id="检查存储过程"><a href="#检查存储过程" class="headerlink" title="检查存储过程"></a>检查存储过程</h3><pre><code class="SQL">// 显示用来创建一个存储过程的 CREATE 语句，使用 SHOW CREATE PROCEDURE 语句
SHOW CREATE PROCEDURE ordertotal;

// 显示包括何时，由谁创建等详细信息的存储过程列表
SHOW PROCEDURE STATUS
// 限制过程状态的结果
SHOW PROCEDURE STATUS LIKE &#39;ordertotal&#39;;
</code></pre>
<h1 id="使用游标"><a href="#使用游标" class="headerlink" title="使用游标"></a>使用游标</h1><h2 id="游标"><a href="#游标" class="headerlink" title="游标"></a>游标</h2><ul>
<li>MySQL 5 添加了对游标的支持。</li>
<li>MySQL 检索操作返回一组称为结果集的行。</li>
<li>有时，需要在检索出来的行中前进或后退一行或多行。这就是游标。游标（cuursor）是一个存储在 MySQl 服务器上的数据库查询，它不是一条 SELECT 语句，而是被该语句检索检索出来的结果集。</li>
<li><p>在存储了游标之后，应用程序可以根据需要滚动或浏览其中的数据。</p>
</li>
<li><p>游标主要用于交互式应用，其中用户需要滚动屏幕上的数据，并对数据进行浏览或做出更改。</p>
</li>
<li>不想多数 DBMS，MySQL 游标只能用于存储过程（和函数）。</li>
</ul>
<h2 id="使用游标-1"><a href="#使用游标-1" class="headerlink" title="使用游标"></a>使用游标</h2><ul>
<li><p>涉及步骤</p>
<ul>
<li>在能够使用游标前，必须声明（定义）它。这个过程实际上没有检索数据，它只是定义要使用的 SELECT 语句。</li>
<li>一旦声明后，必须打开游标以供使用。这个过程用前面定义的 SELECT 语句把数据实际检索出来。</li>
<li>对于填有数据的游标，根据需要取出（检索）各行。</li>
<li>在结束游标使用时，必须关闭游标。</li>
</ul>
</li>
<li><p>在声明游标后，可根据需要频繁地打开和关闭游标。在游标打开后，可根据需要频繁地执行取操作。</p>
</li>
</ul>
<h3 id="创建游标"><a href="#创建游标" class="headerlink" title="创建游标"></a>创建游标</h3><pre><code class="SQL">// 游标用 DECLARE 语句创建。DECLARE 命名游标，并定义相应的 SELECT 语句，根据需要带 WHERE 和其他子句。
CREATE PROCEDURE processorders()
BEGIN
    DECLARE ordernumbers CURSOR
    FOR
    SELECT order_num FROM orders;
END;
// 存储过程处理完成后，游标就消失（因为它局限于存储过程）
// 在定义游标之后，可以打开它。
</code></pre>
<h3 id="打开和关闭游标"><a href="#打开和关闭游标" class="headerlink" title="打开和关闭游标"></a>打开和关闭游标</h3><pre><code class="SQL">// OPEN CURSOR 打开
OPEN ordernumbers;
// 在处理 OPEN 语句时执行查询，存储检索出的数据以供浏览和滚动。

// 游标处理完成后，应当使用如下语句关闭游标：
CLOSE ordernumbers;
// CLOSE 释放游标使用的所有内部内存和资源，因此在每个游标不再需要时都应该关闭。
// 如果你不明确关闭游标，MySQL 将会在到达 END 语句时自动关闭它。

CREATE PROCEDURE processorders()
BEGIN
    -- Declare the cursor
    DECLARE ordernumbers CURSOR
    FOR
    SELECT order_num FROM orders;

    -- Open the cursor
    OPEN ordernumbers;

    -- Close the cursor
    CLOSE ordernumbers;
END;
// 这个存储过程声明打开和关闭一个游标。对检索出的数据什么也没做。
</code></pre>
<h3 id="使用游标数据"><a href="#使用游标数据" class="headerlink" title="使用游标数据"></a>使用游标数据</h3><ul>
<li>在一个游标被打开后，可以使用 FETCH 语句分别访问它的每一行。 FETCH 指定检索什么数据（所需的列），检索出来的数据存储在什么地方。它还向前移动游标中的内部行指针，使下一条 FETCH 语句检索下一行（不重复读取同一行）。</li>
</ul>
<pre><code class="SQL">// 从游标中检索单个行（第一行）
CREATE PROCEDURE processorders()
BEGIN

    -- Declare local variables
    DECLARE o INT;

    -- Declare the cursor
    DECLARE ordernumbers CURSOR
    FOR
    SELECT order_num FROM orders;

    -- Open the cursor
    OPEN ordernumbers;

    -- Get order number
    FETCH numbers INTO o;

    -- Close the cursor
    CLOSE ordernumbers;
END
// FETCH 用来检索当前行的 order_num 列到一个名为 o 的局部变量中。对检索出的数据不做任何处理。
</code></pre>
<ul>
<li>循环检索数据</li>
</ul>
<pre><code class="SQL">CREATE PROCEDURE processorders()
BEGIN

    -- Declare local variables
    DECLARE done BOOLEAN DEFAULT 0;
    DECLARE o INT;

    -- Declare the cursor
    DECLARE ordernumbers CURSOR
    FOR
    SELECT order_num FROM orders;

    -- Declare the cursor
    DECLARE ordernumbers CURSOR
    FOR
    SELECT order_num FROM orders;

    -- Declare continue handler
    DECLARE CONTINUE HANDLER FOR SQLSTATE &#39;02000&#39; SET done =1; // CONTINUE HANDLER 是在条件出现时被执行的代码。
    // SQLSTATE &#39;02000&#39; 是一个未找到条件，当 REPEAT 由于没有更多的行供循环而不能继续时，出现这个条件。

    -- Open the cursor
    OPEN ordernumbers;

    -- Loop through all rows
    REPEAT

        -- Get order number
        FETCH ordernumbers INTO o;
    -- End of loop
    UNTIL done END REPEAT;

    --Close the cursor
    CLOSE ordernumbers;
END
// 反复执行知道 done 为真
</code></pre>
<ul>
<li>DECLARE 语句的发布存在特定的次序。用 DECLARE 语句定义的局部变量必须在定义任意游标或句柄之前定义，而句柄必须在游标之后定义。</li>
</ul>
<pre><code class="SQL">CREATE PROCEDURE processorders()
BEGIN

    -- Declare local variables
    DECLARE done BOOLEAN DEFAUULT 0;
    DECLARE o INT;
    DECLARE t DECIMAL(8,2);

    -- Declare the cursor
    DECLARE ordernumbers FROM orders;
    FOR
    SELECT order_num FROM order;

    -- Declare continue handler
    DECLARE CONTINUE HANDLER FOR SQLSTATE &#39;02000&#39; SET done = 1;
    -- Create a table to store the results
    CREATE TABLE IF NOT EXISTS ordertotals(order_num INT, total DECIMAL(8,2));

    -- Open the cursor
    OPEN ordernumbers;

    -- Loop through all rows
    REPEAT

        -- Get order number
        FETCH ordernumbers INTO o;

        -- Get the total for this order
        CALL ordertotal(o, 1, t);

        -- Insert order and total into ordertotals
        INSERT INTO ordertotal(order_num, total)
        VALUES(o, t);

   -- End of loop
   UNTIL done END REPEAT;

   -- Close the cursor
   CLOSE ordernumbers;

END;

// CALL 执行另一个存储来计算每个订单的待税的合计（结果存储到t）
</code></pre>
<h1 id="触发器"><a href="#触发器" class="headerlink" title="触发器"></a>触发器</h1><h2 id="触发器-1"><a href="#触发器-1" class="headerlink" title="触发器"></a>触发器</h2><ul>
<li>MySQL 5 对触发器支持。</li>
<li><p>触发器是 MySQL 响应以下任意语句而自动执行的一条 MySQL 语句（或者位于 BEGIN 和 END 语句之间的一组语句）</p>
<ul>
<li>DELETE</li>
<li>INSERT</li>
<li>UPDATE</li>
<li>其他 MySQL 语句不支持触发器</li>
</ul>
</li>
</ul>
<h2 id="创建触发器"><a href="#创建触发器" class="headerlink" title="创建触发器"></a>创建触发器</h2><ul>
<li><p>创建，需要给出 4 条信息</p>
<ul>
<li>唯一的触发器名</li>
<li>触发器关联的表</li>
<li>触发器应该响应的活动（DELETE,INSERT或UPDATE）</li>
<li>触发器何时执行（处理之前或之后）</li>
</ul>
</li>
<li><p>在 MySQL 5 中，触发器名必须在每个表中唯一，但不是在每个数据库中唯一。这在其他每个数据库触发器名必须唯一的 DBMS 中是不允许的，以后 MySQL 可能会使命名规则更为严格。因此，现在最好是在数据库范围内使用唯一的触发器名。</p>
</li>
</ul>
<pre><code class="SQL">CREATE TRIGGER newproduct AFTER INSERT ON products
FOR EACH ROW SELECT &#39;Product added&#39;;
// 使用 INSERT 语句添加一行或多行到 products 中，你将看到对每个成功的插入，显示 Product added 消息。
</code></pre>
<ul>
<li>只有表才支持触发器，视图不支持，临时表也不支持。</li>
<li>触发器按每个表每个事件每次地定义，每个表每个事件每次只允许一个触发器。因此每个表最多支持 6 个触发器（每个 INSERT，UPDATE 和 DELETE 之前和之后）</li>
<li>单一触发器不能与多个事件或多个表关联。</li>
<li>如果 BEFORE 触发器失败，则 MySQL 将不执行请求的操作。此外，如果 BEFORE 触发器或语句本身失败，MySQL 将不执行 AFTER 触发器（如果有的话）</li>
</ul>
<h2 id="删除触发器"><a href="#删除触发器" class="headerlink" title="删除触发器"></a>删除触发器</h2><pre><code class="SQL"> DROP TRIGGER newproduct;
 // 触发器不能更新或覆盖。为了修改一个触发器，必须先删除它，然后再重新创建。
</code></pre>
<h2 id="使用触发器"><a href="#使用触发器" class="headerlink" title="使用触发器"></a>使用触发器</h2><h3 id="INSERT-触发器"><a href="#INSERT-触发器" class="headerlink" title="INSERT 触发器"></a>INSERT 触发器</h3><ul>
<li>在 INSERT 触发器代码内，可引用一个名为 NEW 的虚拟表，访问被插入的行。</li>
<li>在 BEFORE INSERT 触发器中，NEW 中的值也可以被更新（允许更改被插入的值）</li>
<li>对于 AUTO_INCREMENT 列，NEW 在 INSERT 执行之前包含 0 ，在 INSERT 执行之后包含新的自动生成的值。</li>
</ul>
<pre><code class="SQL">// 更好的新生成值的方法。
CREATE TRIGGER neworder AFTER INSERT ON orders
FOR EACH ROW SELECT NEW.order_num;
// 在插入一个新订单到 orders 表时，MySQL 生成一个新订单号并保存到 order_num 中。触发器从 NEW.order_num 取得这个值并返回它。
// 对于 orders 的每次插入使用这个触发器将总是返回新的订单号。

// 测试触发器
INSERT INTO orders(order_date, cust_id)
VALUES(Now(), 10001);
// 返回 order_num
// order_num 由 MySQL 自动生成，而现在 order_num 还自动被返回。
</code></pre>
<ul>
<li>通常，将 BEFORE 用于数据验证和净化（目的是保证插入表中的数据确实是需要的数据），本提示也适用于 UPDATE 触发器。</li>
</ul>
<h3 id="DELETE-触发器"><a href="#DELETE-触发器" class="headerlink" title="DELETE 触发器"></a>DELETE 触发器</h3><ul>
<li>在 DELETE 触发器代码内，你可以引用一个名为 OLD 的虚拟表，访问被删除的行。</li>
<li>OLD 中的值全都是只读的，不能更新。</li>
</ul>
<pre><code class="SQL">CREATE TRIGGER deleteorder BEFORE DELETE ON orders
FOR EACH ROW
BEGIN
    INSERT INTO archive_orders(order_num, orderr_date, cust_id)
    VALUES(OLD.order_num, OLD.order_date, OLD.cust_id);
END;
// BEFORE DELETE 触发器的优点（相对于 AFTER DELETE 触发器来说），如果由于某种原因，订单不能存档，DELETE 本身将被抛弃。
</code></pre>
<ul>
<li>触发器 deleteorder 使用 BEGIN 和 END 语句标记触发器体。这不是必需的。使用 BEGIN END 块的好处是触发器能容纳多条 SQL 语句。（在 BEGIN END 块中一条挨着一条）</li>
</ul>
<h3 id="UPDATE-触发器"><a href="#UPDATE-触发器" class="headerlink" title="UPDATE 触发器"></a>UPDATE 触发器</h3><ul>
<li>在 UPDATE 触发器代码中，你可以引用一个名为 OLD 的虚拟表访问以前（UPDATE 语句前）的值，引用一个名为 NEW 的虚拟表访问新更新的值。</li>
<li>在 BEFORE UPDATE 触发器中，NEW 中的值可能也被更新（允许更改将要用于 UPDATE 语句中的值）</li>
<li>OLD 中的值全都是只读的，不能更新。</li>
</ul>
<pre><code class="SQL">CREATE TRIGGER uppdatevendor BEFORE UPDATE ON vendors
FOR EACH ROW SET NEW.vend_state = Upper(NEW.vend_state);
</code></pre>
<h3 id="关于触发器的进一步介绍"><a href="#关于触发器的进一步介绍" class="headerlink" title="关于触发器的进一步介绍"></a>关于触发器的进一步介绍</h3><ul>
<li><p>使用触发器时的重点</p>
<ul>
<li>与其他 DBMS 相比，MySQL 5中支持的触发器相当初级。未来的版本有改进和增强的计划</li>
<li>创建触发器可能需要特殊的安全访问权限，但是，触发器的执行时自动的。如果 INSERT，UPDATE 或 DELETE 语句能够执行，则相关的触发器也能执行。</li>
<li>应该用触发器来保证数据的一致性（大小写，格式等）。在触发器中执行这种类型的处理的优点是它总是进行这种处理，而且是透明地进行，与客户机应用无关。</li>
<li>触发器的一种非常有意义的使用是创建审计跟踪。使用触发器，把更改（如果需要，甚至还有之前和之后的状态）记录到另一个表非常容易。</li>
<li>遗憾的是，MySQL 触发器中不支持 CALL 语句。这表示不能从触发器内调用存储过程。所需的存储过程代码需要复制到触发器内。</li>
</ul>
</li>
</ul>
<h1 id="管理事务处理"><a href="#管理事务处理" class="headerlink" title="管理事务处理"></a>管理事务处理</h1><h2 id="事务处理"><a href="#事务处理" class="headerlink" title="事务处理"></a>事务处理</h2><ul>
<li>MyISAM 和 InnDB 是两种最常使用的引擎。前者不支持明确的事务处理管理，后者支持。</li>
<li>事务处理（transactin pricessing）可以用来维护数据库的完整性，它保证成批的 MySQL 操作要么完全执行，要么完全不执行。</li>
<li>事务处理是一种机制，用来管理必须成批的 MySQL 操作，以保证数据库不包含不完整的操作结果。利用事务处理，可以保证一组操作不会中途停止。它们或者作为整体执行，或者完全不执行（除非明确指示）。</li>
<li>如果错误发生，则进行回退以恢复数据库到某个已知且安全的状态。</li>
</ul>
<ul>
<li><p>术语</p>
<ul>
<li>事务（transaction）：指一组 SQL 语句。</li>
<li>回退（rollback）：指撤销指定 SQL 语句的过程。</li>
<li>提交（commit）：指将未存储的 SQL 语句结果写入数据库表</li>
<li>保留点（savepoint）：指事物处理中设置的临时占位符（place-holder），你可以对它发布回退（与回退整个事务处理不同）</li>
</ul>
</li>
</ul>
<h2 id="控制事务"><a href="#控制事务" class="headerlink" title="控制事务"></a>控制事务</h2><pre><code class="SQL">// 标识事务的开始
START TRANSACTION
</code></pre>
<h3 id="使用-ROLLBACK"><a href="#使用-ROLLBACK" class="headerlink" title="使用 ROLLBACK"></a>使用 ROLLBACK</h3><ul>
<li>MySQL 的 ROLLBACK 命令用来回退（撤销）MySQL 语句</li>
</ul>
<pre><code class="SQL">SELECT * FROM ordertotals;
START TRANSACTION;
DELETE FROM ordertotals;
SELECT * FROM ordertotals;
ROLLBACK;
SELECT * FROM ordertotals;
</code></pre>
<ul>
<li>ROLLBACK 只能在一个事务处理使用（在执行一条 START TRANSACTION 命令之后）</li>
<li>事务处理用来管理 INSERT，UPDATE 和 DELETE 语句。不能回退 SELECT 语句（无意义）。不能回退 CREATE 或 DROP 操作。事务处理中可以使用这两条语句，但如果你执行回退，它们不会被撤销。</li>
</ul>
<h3 id="使用-COMMIT"><a href="#使用-COMMIT" class="headerlink" title="使用 COMMIT"></a>使用 COMMIT</h3><ul>
<li>一般的 MySQL 语句都是直接针对数据库执行和编写的。这就是所谓的隐含提交（implicit commit），即提交（写或保存）操作是自动进行的。</li>
<li>但在事务处理快中，提交不会隐含地进行。明确提交使用 COMMIT 语句</li>
</ul>
<pre><code class="SQL">START TRANSACTION;
DELETE FROM orderitems WHERE order_num = 20010;
DELETE FROM orders WHERE order_num = 20010;
COMMIT;
// COMMIT 语句仅在不出错时写出更改。如果第一条 DELETE 起作用，但第二条失败，则 DELETE 不会提交。（实际上，它是被自动撤销的）
</code></pre>
<ul>
<li>当 COMMIT 或 ROLLBACK 语句执行后，事务会自动关闭（将来的更改会隐含提交）</li>
</ul>
<h3 id="使用保留点"><a href="#使用保留点" class="headerlink" title="使用保留点"></a>使用保留点</h3><ul>
<li>简单的 ROLLBACK 和 COMMIT 语句就可以写入或撤销整个事务处理。但是，只是对简单的事务处理才能这样做，更复杂的事务处理可能需要部分提交或回退。</li>
</ul>
<pre><code class="SQL">// 创建占位符
SAVEPOINT delete1;
</code></pre>
<ul>
<li>每个保留点都取标识它的唯一名字，以便在回退时，MySQL 知道要回退到何处。为了回退到本例给出的保留点。</li>
</ul>
<pre><code class="SQL">ROLLBACK TO delete1;
</code></pre>
<ul>
<li>可以在 MySQl 代码中设置任意多的保留点，越多越好，因为保留点越多，你就能按照自己的意愿灵活地进行回退。</li>
<li>保留点在事务处理完成（执行一条 ROLLBACK 或 COMMIT）后自动释放。自 MySQL 5 以来，也可以用 RELEASE SAVEPOINT 明确地释放保留点。</li>
</ul>
<h3 id="更改默认的提交行为"><a href="#更改默认的提交行为" class="headerlink" title="更改默认的提交行为"></a>更改默认的提交行为</h3><pre><code class="SQL">// 默认的 MySQL 行为是自动提交所有更改。为指示 MySQl 不自动提交更改，需要使用以下语句：
SET autocommit=0;
</code></pre>
<ul>
<li>autocommit标志决定是否自动提交更改，不管有没有 COMMIT 语句。设置  autocommit 为 0（假）指示 MySQL 不自动提交更改（知道 autocommit被设置为真为止）</li>
<li>autocommit 标志是针对每个联结而不是服务器的。</li>
</ul>
<h1 id="全球化和本地化"><a href="#全球化和本地化" class="headerlink" title="全球化和本地化"></a>全球化和本地化</h1><h2 id="字符集和校对顺序"><a href="#字符集和校对顺序" class="headerlink" title="字符集和校对顺序"></a>字符集和校对顺序</h2><ul>
<li>数据库被用来存储和检索数据。不同的语言和字符集需要以不同的方式存储和检索。</li>
<li><p>术语</p>
<ul>
<li>字符集 为字母和符号的集合</li>
<li>编码 为某个字符集成员的内部表示</li>
<li>校对 为规定字符如何比较的指令</li>
</ul>
</li>
<li><p>使用何种字符集和校对的决定在服务器，数据库和表级进行。</p>
</li>
</ul>
<h2 id="使用字符集和校对顺序"><a href="#使用字符集和校对顺序" class="headerlink" title="使用字符集和校对顺序"></a>使用字符集和校对顺序</h2><pre><code class="SQL">SHOW CHARACTER SET;
// 显示所有可用的字符集以及每个字符集的描述和默认校对

SHOW COLLATION;
// 显示所有可用校对，以及它们适合的字符集。
// 区分大小写（由 _cs 表示）一次不区分大小写（由 _ci 表示）

// 通常系统管理在安装时定义一个默认的字符集和校对。也可以在数据库时，创建默认的字符集和校对
// 确定所用的字符集和校对
SHOW VARIABLES LIKE &#39;character%&#39;;
SHOW VARIABLES LIKE &#39;collation%&#39;;
</code></pre>
<ul>
<li>字符集很少是服务器范围（甚至数据库范围）的设置。不同的表，甚至不同的列都可能需要不同的字符集，而且两者都可以在创建表时指定。</li>
</ul>
<pre><code class="SQL">CREATE TABLE mytable
(
    columnn1 INT,
    columnn2 VARCHAR(10)
) DEFAULT CHARACTER SET hebrew
  COLLATE hebrew_general_ci;

// MySQL 还允许对每个列设置它们
CREATE TABLE mytable
(
    columnn1 INT,
    columnn2 VARCHAR(10),
    column3  VARCHAR(10) CHARACTER SET latin1 COLLATE latin1_general_ci
) DEFAULT CHARACTER SET hebrew
  COLLATE hebrew_generral_ci;
// 对整个表和特定的列指定了 CHARACTER SET 和 COLLATE

// 如果创建表时不同的校对顺序排序特定的 SELECT 语句，可以在 SELECT 语句自身中进行
SELECT * FROM customers
ORDER BY lastname, firstname COLLATE latin1_general_cs;
// 使用 COLLATE 指定一个备用的校对顺序（为区分大小写的校对）
</code></pre>
<ul>
<li>COLLATE 还可以用于 GROUP BY ，HAVING ，聚集函数，别名</li>
<li>如果绝对需要，串可以在字符集之间进行转换。为此使用 Cast() 或 Convert()函数</li>
</ul>
<h1 id="安全管理"><a href="#安全管理" class="headerlink" title="安全管理"></a>安全管理</h1><h2 id="访问控制"><a href="#访问控制" class="headerlink" title="访问控制"></a>访问控制</h2><ul>
<li><p>MySQL 服务器的安全基础时：用户应该对他们需要的数据具有适当的访问权，即不能多也不能少。换句话说，用户不能对过多的数据具有过多的访问权。</p>
</li>
<li><p>在现实的工作中，绝不能使用 root。应该创建一系列的账号，有的用于管理，有的用于供用户使用，有的供开发人员使用。</p>
</li>
</ul>
<h2 id="管理用户"><a href="#管理用户" class="headerlink" title="管理用户"></a>管理用户</h2><ul>
<li>MySQL 用户账户和信息存储在名为 mysql 的 MySQL 数据库中。一般不需哟啊直接访问 mysql 数据库和表，但有时需要直接访问。</li>
</ul>
<pre><code class="SQL">USER mysql;
SELECT user FROM user;
// user 表，user 列，存储用户登录名。
</code></pre>
<h3 id="创建用户账号"><a href="#创建用户账号" class="headerlink" title="创建用户账号"></a>创建用户账号</h3><pre><code class="SQL">CREATE USER ben IDENTIFIED BY &#39;p@$$w0rd&#39;;
// 创建用户账号不一定需要口令
// IDENTIFIED BY 指定的口令为纯文本，MySQL 将在保存到 user 表之前对其进行加密。
</code></pre>
<ul>
<li><p>也可以通过直接插入行到 user 表来增加用户，不过为安全起见，一般不建议这样做。因此，相对于直接处理来说，最好是用标记和函数来处理这些表。</p>
</li>
<li><p>重命名一个用户账号</p>
</li>
</ul>
<pre><code class="SQL">RENAME USER ben TO bforta;
// 仅 MySQL 5或之后的版本支持 RENAME USER。
// 之前的 MySQL ，使用 UPDATE 直接更新 user 表
</code></pre>
<h3 id="删除用户账号"><a href="#删除用户账号" class="headerlink" title="删除用户账号"></a>删除用户账号</h3><ul>
<li>删除一个用户账号（以及相关的权限）</li>
</ul>
<pre><code class="SQL">DROP USER bforta;
// MySQL 5 以来，DROP USER 删除用户的账号和所有相关的账号权限。
// 5 之前，只能删除用户账号，不能删除相关的权限。所以需要先使用 REVOKE 删除与账号相关的权限，然后再用 DROP USER 删除账号
</code></pre>
<h3 id="设置访问权限"><a href="#设置访问权限" class="headerlink" title="设置访问权限"></a>设置访问权限</h3><ul>
<li>在创建用户账号，必须接着分配访问权限。新创建的用户账号没有访问权限 。它们能登录 MySQL ，但不能看到数据，不能执行任何数据库操作。</li>
</ul>
<pre><code class="SQL">// 看到赋予用户账号的权限
SHOW GRANTS FOR bforta;
// 显示为用户 bforta 有一个权限 `USAGE ON *.*` USAGE 表示根本没有权限。
</code></pre>
<ul>
<li>MySQl 的权限用用户名和主机名结合定义( user@host )。如果不指定主机名，则使用默认的主机名%</li>
<li><p>设置权限，使用 GRANT 语句</p>
<ul>
<li>要授予的权限</li>
<li>被授予访问权限的数据库或表</li>
<li>用户名</li>
</ul>
</li>
</ul>
<pre><code class="SQL">GRANT SELECT ON crashcourse.* TO bforta;
// 允许用户在 crashcourse 数据库的所有表上使用 SELECT。

// 撤销特定的权限
REVOKE SELECT ON crashcourse.* FROM bforta;
</code></pre>
<ul>
<li><p>GRANT 和 REVOKE 可在几个层次上控制访问权限</p>
<ul>
<li>整个服务器，使用 GRANT ALL 和 REVOKE ALL</li>
<li>整个数据库，使用 ON database.*</li>
<li>特定的表，使用 ON databse.table</li>
<li>特定的列</li>
<li>特定的存储过程</li>
</ul>
</li>
<li><p>权限</p>
</li>
</ul>
<pre><code class="SQL">ALL     //
ALTER
ALTER ROUTINE
CREATE
CREATE ROUTINE
CREATE TEMPORARY TABLES
CREATE USER
CREATE VIEW
DELETE
DROP
EXECUTE     // 使用 CALL 和 存储过程
FILE
GRANT OPTION
INDEX
INSERT
LOCK TABLES
PROCESS
RELOAD
REPLICATION CLIENT // 服务器位置的访问
REPLICATION SLAVE // 由复制从属使用
SELECT
SHOW DATABASES
SHOW VIEW
SHUTDOWN
SUPER
UPDATE
USAGE // 无访问权限
</code></pre>
<ul>
<li>简化多次授权。</li>
</ul>
<pre><code class="SQL">GRANT SELECT, INERT ON crashcourse.* TO bforta;
</code></pre>
<h3 id="更改口令"><a href="#更改口令" class="headerlink" title="更改口令"></a>更改口令</h3><pre><code class="SQL"> SET PASSWORD FOR beforta = Password(&#39;n3w p@$$w0rd&#39;);
 // SET PASSWORD 更新用户口令。新口令必须传递到 Password()函数进行加密。

 // 设置自己的口令，不指定用户名，更新当前登录的用户的口令
 SET PASSWORD = PASSword(&#39;n2w p@$$w0rd&#39;);
</code></pre>
<h1 id="数据库维护"><a href="#数据库维护" class="headerlink" title="数据库维护"></a>数据库维护</h1><h2 id="备份数据"><a href="#备份数据" class="headerlink" title="备份数据"></a>备份数据</h2><ul>
<li><p>解决方案</p>
<ul>
<li>使用命令行实用程序 mysqldump 转储所有数据库内容到某个外部文件。</li>
<li>可用命令行实用程序 mysqlhotcopy 从一个数据库复制所有数据（并非所有数据库引擎都支持这个实用程序）</li>
<li>可用使用 MySQL 的 BACKUP TABLE 或 SELECT INTO OUTFILE 转储所有数据到某个外部文件。数据可以用 RESTONE TABLE 来复原</li>
</ul>
</li>
<li><p>为了保证所有数据被写到磁盘（包括索引数据），可能需要在进行备份前使用 FLUSH TABLES 语句</p>
</li>
</ul>
<h2 id="进行数据库维护"><a href="#进行数据库维护" class="headerlink" title="进行数据库维护"></a>进行数据库维护</h2><pre><code class="SQL">// ANALYZE TABLE 用来检查表键是否正确
ANALYZE TABLE orders;

// CHECK TABLE 用来针对许多问题对表进行检查。在 MyISAM 表上还对索引进行检查。发现和修复问题
CHECK TABLE orders, orderitems;

// CHANGED 检查来自最后一次检查以来改动过的表
// EXTENDED 执行最彻底的检查
// FAST 只检查为正常关闭的表
// MEDIUM 检查所有被删除的链接并进行键检验
// QUICK 只进行快速扫描
</code></pre>
<ul>
<li>如果 MyISAM 表访问产生不正确和不一致的结果，可能需要用 REPAIR TABLE 来修复相应的表。</li>
<li>如果从一个表中删除大量数据，应该使用 OPTIMIZE TABLE 来收回所用的空间，从而优化性能。</li>
</ul>
<h2 id="诊断启动问题"><a href="#诊断启动问题" class="headerlink" title="诊断启动问题"></a>诊断启动问题</h2><ul>
<li>在排除系统启动问题时，首先应该尽量用手动启动服务器。</li>
<li>MySQL 服务器自身通过在命令行上执行 mysqld 启动。</li>
<li><p>几个 mysqld 命令行选项</p>
<ul>
<li>–help // 显示帮助</li>
<li>–safe-mode // 装载减去某些最佳配置的服务器</li>
<li>–verbose // 显示全文本信息</li>
<li>–version // 显示版本信息然后推出</li>
</ul>
</li>
</ul>
<h2 id="查看日志文件"><a href="#查看日志文件" class="headerlink" title="查看日志文件"></a>查看日志文件</h2><ul>
<li><p>错误日志。</p>
<ul>
<li>它包含启动和关闭问题以及任意关键错误的细节。</li>
<li>此日志通常名为 hostname.err，位于 data 目录中。此日志名可用 –log-error 命令行选项更改</li>
</ul>
</li>
<li><p>查询日志。</p>
<ul>
<li>它记录所有 MySQL 活动，在诊断问题时非常有用。</li>
<li>此日志文件可能会很快地变得非常大，因此不应该长期使用它。</li>
<li>此日志通常名为 hostname.log ，位于 data 目录中。此名字可以用 –log 命令行选项更改。</li>
</ul>
</li>
<li><p>二进制日志。（MySQL 5 以前版本使用是更新日志）</p>
<ul>
<li>它记录更新过数据（或者可能更新过数据）的所有语句。</li>
<li>此日志通常名为 hostname-bin，位于 data 目录内。</li>
<li>此名字可以用 –log-bin 命令行选项更改。</li>
</ul>
</li>
<li><p>缓慢查询日志</p>
<ul>
<li>此日志记录执行缓慢的任何查询</li>
<li>这个日志在确定数据库何处需要优化很有用。</li>
<li>此日志通常名为 hostname-slow.log ，位于 data 目录中。此名字可以用 –log-slow-queries 命令行选项更改</li>
</ul>
</li>
</ul>
<ul>
<li>可用 FLUSH LOGS 语句来刷新和重新开始所有日志文件。</li>
</ul>
<h1 id="改善性能"><a href="#改善性能" class="headerlink" title="改善性能"></a>改善性能</h1><ul>
<li>MySQL 具有特定的硬件建议（对于生产的服务器来说）</li>
<li>一般来说，关键的生产 DBMS 应该运行在自己的专用服务器上。</li>
<li><p>MySQL 是用一系列的默认设置预先配置的，从这些设置开始通常是很好的。</p>
<ul>
<li>但过一段时间后你可能需要调整内存分配，缓冲区大小等。</li>
<li>查看当前设置，使用 SHOW VARIABLES; 和 SHOW STATUS;</li>
</ul>
</li>
<li><p>MySQL 一个多用户多线程的 DBMS 换言之，它经常同时执行多个任务。</p>
<ul>
<li>如果这些任务中的某一个执行缓慢，则所有请求都会执行缓慢。</li>
<li>如果你遇到显著的性能不良，可使用 SHOW PROCESSLIST 显示所有活动进程（以及它们的线程 ID 和执行时间）</li>
<li>可以用 KILL 命令终结某个特定的进程（这个命令需要作为管理员登录）</li>
</ul>
</li>
<li><p>总是有不止一种方法编写同一条 SELECT 语句。应该试验联结，并，子查询等。找出最佳的方法。</p>
</li>
<li>使用 EXPLAIN 语句让 MySQL 解释它将如何执行一条 SELECT 语句。</li>
<li>一般来说，存储过程执行得比一条一条 地执行其中的各条 MySQL 语句快。</li>
<li>应该总是使用正确的数据类型。</li>
<li>决不要检索比需求还要多的数据。换言之，不要用 SELECT * (除非你真正需要每个列)</li>
<li>有的操作（包括 INSERT ）支持一个可选的 DELAYED 关键字，如果使用它，将把控制立即返回给调用程序，并且一旦有可能就实际执行该操作。</li>
<li><p>在导入数据时，应该关闭自动提交。你可能还想删除索引（包括 FULLTEXT 索引），然后在导入完成后再重建它们。</p>
</li>
<li><p>必须索引数据库以改善数据检索的性能。</p>
<ul>
<li>确定索引什么不适一件微不足道的任务，需要分析使用的 SELECT 语句以找出重复的 WHERE 和 ORDER BY 子句。</li>
<li>如果一个简单的 WHERE 子句返回结果所花的时间太长，则可以断定其中使用的列（或几个列）就是需要索引的对象。</li>
</ul>
</li>
<li><p>你的 SELECT 语句中有一系列复杂的 OR 条件吗？通过使用多条 SELECT 语句和连接它们的 UNION 语句，你能看到极大的性能改进。</p>
</li>
<li><p>索引改善数据检索的性能，但损害数据插入，删除和更新的性能。</p>
<ul>
<li>如果你有一些表，它们收集数据且不经常被搜索，则在有必要之前不要索引它们。（索引可根据需要添加和删除）</li>
</ul>
</li>
<li><p>LIKE 很慢。一般来说，最好是使用 FULLTEXT 而不是 LIKE</p>
</li>
<li>数据库是不断变化的实体。一组优化良好的表一会儿可能就面目全非了。由于表的使用和内容的更改，理想的优化和配置也会改变。</li>
<li><p>最重要的规则就是，每条规则在某些条件下都会被打破。</p>
</li>
<li><p><a href="http://dev.mysql.com/doc/" target="_blank" rel="external">MySQl 文档</a> 有许多提示和技巧。</p>
</li>
</ul>
<h1 id="附录A-MySQL-入门"><a href="#附录A-MySQL-入门" class="headerlink" title="附录A MySQL 入门"></a>附录A MySQL 入门</h1><h1 id="附录B-样例表"><a href="#附录B-样例表" class="headerlink" title="附录B 样例表"></a>附录B 样例表</h1><h1 id="附录C-MySQL-语句的语法"><a href="#附录C-MySQL-语句的语法" class="headerlink" title="附录C MySQL 语句的语法"></a>附录C MySQL 语句的语法</h1><h1 id="附录D-MySQL-数据类型"><a href="#附录D-MySQL-数据类型" class="headerlink" title="附录D MySQL 数据类型"></a>附录D MySQL 数据类型</h1><h1 id="附录E-MySQL-保留字"><a href="#附录E-MySQL-保留字" class="headerlink" title="附录E MySQL 保留字"></a>附录E MySQL 保留字</h1>
 
                <!-- Meta -->
                <div class="post-meta">
                    <hr>
                    <br>
                    <div class="post-tags">
                        
                            

<a href="/tags/MySQL/">#MySQL</a>


                        
                    </div>
                    <div class="post-date">
                        2017 年 05 月 15 日
                    </div>
                </div>
            </div>

            <!-- Comments -->
            <div class="col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
                <!-- Disqus Comments -->


            </div>
        </div>
    </div>
</article>
</section>

    <!-- Scripts -->
    <!-- jQuery -->
<script src="//cdn.bootcss.com/jquery/2.2.1/jquery.min.js"></script>
<!-- Bootstrap -->
<script src="//cdn.bootcss.com/bootstrap/3.3.6/js/bootstrap.min.js"></script>

<script type="text/javascript">
	hljs.initHighlightingOnLoad();
	console.log('Hexo-theme-hollow designed by zchen9 http://www.chen9.info © 2015-' + (new Date()).getFullYear());
</script>

    <!-- Google Analytics -->
    

</body>

</html>